r8806: Move data representation-independent data into seperate header
authorJelmer Vernooij <jelmer@samba.org>
Wed, 27 Jul 2005 21:09:16 +0000 (21:09 +0000)
committerGerald (Jerry) Carter <jerry@samba.org>
Wed, 10 Oct 2007 18:30:06 +0000 (13:30 -0500)
(This used to be commit 26e1fdf63007e28468a05b18bede1e69981edc12)

source4/build/pidl/Parse/Pidl/Samba/EJS.pm
source4/build/pidl/Parse/Pidl/Samba/Header.pm [new file with mode: 0644]
source4/build/pidl/Parse/Pidl/Samba/NDR/Header.pm
source4/build/pidl/Parse/Pidl/Samba/NDR/Parser.pm
source4/build/pidl/pidl
source4/include/includes.h
source4/script/build_idl.sh

index 370db6d0e44f163023e06785ca01e9bcafdd1d22..5cd7b462aee1584582657e374020005f444e2604 100644 (file)
@@ -750,7 +750,6 @@ sub Parse($$)
     return $res;
 }
 
-
 sub NeededFunction($$)
 {
        my ($fn,$needed) = @_;
diff --git a/source4/build/pidl/Parse/Pidl/Samba/Header.pm b/source4/build/pidl/Parse/Pidl/Samba/Header.pm
new file mode 100644 (file)
index 0000000..21b239b
--- /dev/null
@@ -0,0 +1,354 @@
+###################################################
+# create C header files for an IDL structure
+# Copyright tridge@samba.org 2000
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::Header;
+
+use strict;
+use Parse::Pidl::Typelist qw(mapType);
+use Parse::Pidl::Util qw(has_property is_constant);
+use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel);
+
+my($res);
+my($tab_depth);
+
+sub pidl ($)
+{
+       $res .= shift;
+}
+
+sub tabs()
+{
+       my $res = "";
+       $res .="\t" foreach (1..$tab_depth);
+       return $res;
+}
+
+#####################################################################
+# parse a properties list
+sub HeaderProperties($$)
+{
+    my($props,$ignores) = @_;
+       my $ret = "";
+
+    foreach my $d (keys %{$props}) {
+               next if (grep(/^$d$/, @$ignores));
+               if($props->{$d} ne "1") {
+                       $ret.= "$d($props->{$d}),";
+               } else {
+                       $ret.="$d,";
+               }
+       }
+
+       if ($ret) {
+               pidl "/* [" . substr($ret, 0, -1) . "] */";
+       }
+}
+
+#####################################################################
+# parse a structure element
+sub HeaderElement($)
+{
+       my($element) = shift;
+
+       pidl tabs();
+       HeaderType($element, $element->{TYPE}, "");
+       pidl " ";
+       my $numstar = $element->{POINTERS};
+       foreach (@{$element->{ARRAY_LEN}})
+       {
+               next if is_constant($_);
+               $numstar++;
+       }
+       $numstar-- if ($element->{TYPE} eq "string");
+       pidl "*" foreach (1..$numstar);
+       pidl $element->{NAME};
+       foreach (@{$element->{ARRAY_LEN}}) {
+               next unless is_constant($_);
+               pidl "[$_]";
+       }
+
+       pidl ";";
+       if (defined $element->{PROPERTIES}) {
+               HeaderProperties($element->{PROPERTIES}, ["in", "out"]);
+       }
+       pidl "\n";
+}
+
+#####################################################################
+# parse a struct
+sub HeaderStruct($$)
+{
+    my($struct,$name) = @_;
+       pidl "struct $name {\n";
+    $tab_depth++;
+    my $el_count=0;
+    if (defined $struct->{ELEMENTS}) {
+               foreach my $e (@{$struct->{ELEMENTS}}) {
+                   HeaderElement($e);
+                   $el_count++;
+               }
+    }
+    if ($el_count == 0) {
+           # some compilers can't handle empty structures
+           pidl tabs()."char _empty_;\n";
+    }
+    $tab_depth--;
+    pidl tabs()."}";
+       if (defined $struct->{PROPERTIES}) {
+               HeaderProperties($struct->{PROPERTIES}, []);
+       }
+}
+
+#####################################################################
+# parse a enum
+sub HeaderEnum($$)
+{
+    my($enum,$name) = @_;
+    my $first = 1;
+
+    if (not Parse::Pidl::Util::useUintEnums()) {
+       pidl "enum $name {\n";
+       $tab_depth++;
+       foreach my $e (@{$enum->{ELEMENTS}}) {
+           unless ($first) { pidl ",\n"; }
+           $first = 0;
+           pidl tabs();
+           pidl $e;
+       }
+       pidl "\n";
+       $tab_depth--;
+       pidl "}";
+    } else {
+        my $count = 0;
+       pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n";
+       my $with_val = 0;
+       my $without_val = 0;
+       foreach my $e (@{$enum->{ELEMENTS}}) {
+           my $t = "$e";
+           my $name;
+           my $value;
+           if ($t =~ /(.*)=(.*)/) {
+               $name = $1;
+               $value = $2;
+               $with_val = 1;
+               die ("you can't mix enum member with values and without values when using --uint-enums!")
+                       unless ($without_val == 0);
+           } else {
+               $name = $t;
+               $value = $count++;
+               $without_val = 1;
+               die ("you can't mix enum member with values and without values when using --uint-enums!")
+                       unless ($with_val == 0);
+           }
+           pidl "#define $name ( $value )\n";
+       }
+       pidl "\n";
+    }
+}
+
+#####################################################################
+# parse a bitmap
+sub HeaderBitmap($$)
+{
+    my($bitmap,$name) = @_;
+
+    pidl "/* bitmap $name */\n";
+    pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}});
+    pidl "\n";
+}
+
+#####################################################################
+# parse a union
+sub HeaderUnion($$)
+{
+       my($union,$name) = @_;
+       my %done = ();
+
+       pidl "union $name {\n";
+       $tab_depth++;
+       foreach my $e (@{$union->{ELEMENTS}}) {
+               if ($e->{TYPE} ne "EMPTY") {
+                       if (! defined $done{$e->{NAME}}) {
+                               HeaderElement($e);
+                       }
+                       $done{$e->{NAME}} = 1;
+               }
+       }
+       $tab_depth--;
+       pidl "}";
+
+       if (defined $union->{PROPERTIES}) {
+               HeaderProperties($union->{PROPERTIES}, []);
+       }
+}
+
+#####################################################################
+# parse a type
+sub HeaderType($$$)
+{
+       my($e,$data,$name) = @_;
+       if (ref($data) eq "HASH") {
+               ($data->{TYPE} eq "ENUM") && HeaderEnum($data, $name);
+               ($data->{TYPE} eq "BITMAP") && HeaderBitmap($data, $name);
+               ($data->{TYPE} eq "STRUCT") && HeaderStruct($data, $name);
+               ($data->{TYPE} eq "UNION") && HeaderUnion($data, $name);
+               return;
+       }
+
+       if (has_property($e, "charset")) {
+               pidl "const char";
+       } else {
+               pidl mapType($e->{TYPE});
+       }
+}
+
+#####################################################################
+# parse a typedef
+sub HeaderTypedef($)
+{
+    my($typedef) = shift;
+    HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME});
+    pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP");
+}
+
+#####################################################################
+# parse a const
+sub HeaderConst($)
+{
+    my($const) = shift;
+    if (!defined($const->{ARRAY_LEN}[0])) {
+       pidl "#define $const->{NAME}\t( $const->{VALUE} )\n";
+    } else {
+       pidl "#define $const->{NAME}\t $const->{VALUE}\n";
+    }
+}
+
+#####################################################################
+# parse a function
+sub HeaderFunctionInOut($$)
+{
+    my($fn,$prop) = @_;
+
+    foreach my $e (@{$fn->{ELEMENTS}}) {
+           if (has_property($e, $prop)) {
+                   HeaderElement($e);
+           }
+    }
+}
+
+#####################################################################
+# determine if we need an "in" or "out" section
+sub HeaderFunctionInOut_needed($$)
+{
+    my($fn,$prop) = @_;
+
+    return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void");
+
+    foreach (@{$fn->{ELEMENTS}}) {
+           return 1 if (has_property($_, $prop));
+    }
+
+    return undef;
+}
+
+my %headerstructs = ();
+
+#####################################################################
+# parse a function
+sub HeaderFunction($)
+{
+    my($fn) = shift;
+
+    return if ($headerstructs{$fn->{NAME}});
+
+    $headerstructs{$fn->{NAME}} = 1;
+
+    pidl "\nstruct $fn->{NAME} {\n";
+    $tab_depth++;
+    my $needed = 0;
+
+    if (HeaderFunctionInOut_needed($fn, "in")) {
+           pidl tabs()."struct {\n";
+           $tab_depth++;
+           HeaderFunctionInOut($fn, "in");
+           $tab_depth--;
+           pidl tabs()."} in;\n\n";
+           $needed++;
+    }
+
+    if (HeaderFunctionInOut_needed($fn, "out")) {
+           pidl tabs()."struct {\n";
+           $tab_depth++;
+           HeaderFunctionInOut($fn, "out");
+           if ($fn->{RETURN_TYPE} ne "void") {
+                   pidl tabs().mapType($fn->{RETURN_TYPE}) . " result;\n";
+           }
+           $tab_depth--;
+           pidl tabs()."} out;\n\n";
+           $needed++;
+    }
+
+    if (! $needed) {
+           # sigh - some compilers don't like empty structures
+           pidl tabs()."int _dummy_element;\n";
+    }
+
+    $tab_depth--;
+    pidl "};\n\n";
+}
+
+#####################################################################
+# parse the interface definitions
+sub HeaderInterface($)
+{
+       my($interface) = shift;
+
+       my $count = 0;
+
+       pidl "#ifndef _HEADER_$interface->{NAME}\n";
+       pidl "#define _HEADER_$interface->{NAME}\n\n";
+
+       if (defined $interface->{PROPERTIES}->{depends}) {
+               my @d = split / /, $interface->{PROPERTIES}->{depends};
+               foreach my $i (@d) {
+                       pidl "#include \"librpc/gen_ndr/$i\.h\"\n";
+               }
+       }
+
+       foreach my $d (@{$interface->{DATA}}) {
+               next if ($d->{TYPE} ne "CONST");
+               HeaderConst($d);
+       }
+
+       foreach my $d (@{$interface->{DATA}}) {
+               next if ($d->{TYPE} ne "TYPEDEF");
+               HeaderTypedef($d);
+       }
+
+       foreach my $d (@{$interface->{DATA}}) {
+               next if ($d->{TYPE} ne "FUNCTION");
+               HeaderFunction($d);
+       }
+
+       pidl "#endif /* _HEADER_$interface->{NAME} */\n";
+}
+
+#####################################################################
+# parse a parsed IDL into a C header
+sub Parse($)
+{
+    my($idl) = shift;
+    $tab_depth = 0;
+
+       $res = "";
+    pidl "/* header auto-generated by pidl */\n\n";
+    foreach my $x (@{$idl}) {
+           ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
+    }
+    return $res;
+}
+
+1;
index a460d1c58821e92a3088912f9d6f3e7e82431b65..9aa0ed8daf7ca48d287ad20bb6f8a934db3515bf 100644 (file)
@@ -27,194 +27,6 @@ sub tabs()
        return $res;
 }
 
-#####################################################################
-# parse a properties list
-sub HeaderProperties($$)
-{
-    my($props,$ignores) = @_;
-       my $ret = "";
-
-    foreach my $d (keys %{$props}) {
-               next if (grep(/^$d$/, @$ignores));
-               if($props->{$d} ne "1") {
-                       $ret.= "$d($props->{$d}),";
-               } else {
-                       $ret.="$d,";
-               }
-       }
-
-       if ($ret) {
-               pidl "/* [" . substr($ret, 0, -1) . "] */";
-       }
-}
-
-#####################################################################
-# parse a structure element
-sub HeaderElement($)
-{
-       my($element) = shift;
-
-       pidl tabs();
-       HeaderType($element, $element->{TYPE}, "");
-       pidl " ";
-       my $numstar = $element->{POINTERS};
-       foreach (@{$element->{ARRAY_LEN}})
-       {
-               next if is_constant($_);
-               $numstar++;
-       }
-       $numstar-- if ($element->{TYPE} eq "string");
-       pidl "*" foreach (1..$numstar);
-       pidl $element->{NAME};
-       foreach (@{$element->{ARRAY_LEN}}) {
-               next unless is_constant($_);
-               pidl "[$_]";
-       }
-
-       pidl ";";
-       if (defined $element->{PROPERTIES}) {
-               HeaderProperties($element->{PROPERTIES}, ["in", "out"]);
-       }
-       pidl "\n";
-}
-
-#####################################################################
-# parse a struct
-sub HeaderStruct($$)
-{
-    my($struct,$name) = @_;
-       pidl "struct $name {\n";
-    $tab_depth++;
-    my $el_count=0;
-    if (defined $struct->{ELEMENTS}) {
-               foreach my $e (@{$struct->{ELEMENTS}}) {
-                   HeaderElement($e);
-                   $el_count++;
-               }
-    }
-    if ($el_count == 0) {
-           # some compilers can't handle empty structures
-           pidl tabs()."char _empty_;\n";
-    }
-    $tab_depth--;
-    pidl tabs()."}";
-       if (defined $struct->{PROPERTIES}) {
-               HeaderProperties($struct->{PROPERTIES}, []);
-       }
-}
-
-#####################################################################
-# parse a enum
-sub HeaderEnum($$)
-{
-    my($enum,$name) = @_;
-    my $first = 1;
-
-    if (not Parse::Pidl::Util::useUintEnums()) {
-       pidl "enum $name {\n";
-       $tab_depth++;
-       foreach my $e (@{$enum->{ELEMENTS}}) {
-           unless ($first) { pidl ",\n"; }
-           $first = 0;
-           pidl tabs();
-           pidl $e;
-       }
-       pidl "\n";
-       $tab_depth--;
-       pidl "}";
-    } else {
-        my $count = 0;
-       pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n";
-       my $with_val = 0;
-       my $without_val = 0;
-       foreach my $e (@{$enum->{ELEMENTS}}) {
-           my $t = "$e";
-           my $name;
-           my $value;
-           if ($t =~ /(.*)=(.*)/) {
-               $name = $1;
-               $value = $2;
-               $with_val = 1;
-               die ("you can't mix enum member with values and without values when using --uint-enums!")
-                       unless ($without_val == 0);
-           } else {
-               $name = $t;
-               $value = $count++;
-               $without_val = 1;
-               die ("you can't mix enum member with values and without values when using --uint-enums!")
-                       unless ($with_val == 0);
-           }
-           pidl "#define $name ( $value )\n";
-       }
-       pidl "\n";
-    }
-}
-
-#####################################################################
-# parse a bitmap
-sub HeaderBitmap($$)
-{
-    my($bitmap,$name) = @_;
-
-    pidl "/* bitmap $name */\n";
-    pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}});
-    pidl "\n";
-}
-
-#####################################################################
-# parse a union
-sub HeaderUnion($$)
-{
-       my($union,$name) = @_;
-       my %done = ();
-
-       pidl "union $name {\n";
-       $tab_depth++;
-       foreach my $e (@{$union->{ELEMENTS}}) {
-               if ($e->{TYPE} ne "EMPTY") {
-                       if (! defined $done{$e->{NAME}}) {
-                               HeaderElement($e);
-                       }
-                       $done{$e->{NAME}} = 1;
-               }
-       }
-       $tab_depth--;
-       pidl "}";
-
-       if (defined $union->{PROPERTIES}) {
-               HeaderProperties($union->{PROPERTIES}, []);
-       }
-}
-
-#####################################################################
-# parse a type
-sub HeaderType($$$)
-{
-       my($e,$data,$name) = @_;
-       if (ref($data) eq "HASH") {
-               ($data->{TYPE} eq "ENUM") && HeaderEnum($data, $name);
-               ($data->{TYPE} eq "BITMAP") && HeaderBitmap($data, $name);
-               ($data->{TYPE} eq "STRUCT") && HeaderStruct($data, $name);
-               ($data->{TYPE} eq "UNION") && HeaderUnion($data, $name);
-               return;
-       }
-
-       if (has_property($e, "charset")) {
-               pidl "const char";
-       } else {
-               pidl mapType($e->{TYPE});
-       }
-}
-
-#####################################################################
-# parse a typedef
-sub HeaderTypedef($)
-{
-    my($typedef) = shift;
-    HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME});
-    pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP");
-}
-
 #####################################################################
 # prototype a typedef
 sub HeaderTypedefProto($)
@@ -241,92 +53,6 @@ sub HeaderTypedefProto($)
     }
 }
 
-#####################################################################
-# parse a const
-sub HeaderConst($)
-{
-    my($const) = shift;
-    if (!defined($const->{ARRAY_LEN}[0])) {
-       pidl "#define $const->{NAME}\t( $const->{VALUE} )\n";
-    } else {
-       pidl "#define $const->{NAME}\t $const->{VALUE}\n";
-    }
-}
-
-#####################################################################
-# parse a function
-sub HeaderFunctionInOut($$)
-{
-    my($fn,$prop) = @_;
-
-    foreach my $e (@{$fn->{ELEMENTS}}) {
-           if (has_property($e, $prop)) {
-                   HeaderElement($e);
-           }
-    }
-}
-
-#####################################################################
-# determine if we need an "in" or "out" section
-sub HeaderFunctionInOut_needed($$)
-{
-    my($fn,$prop) = @_;
-
-    return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void");
-
-    foreach (@{$fn->{ELEMENTS}}) {
-           return 1 if (has_property($_, $prop));
-    }
-
-    return undef;
-}
-
-my %headerstructs = ();
-
-#####################################################################
-# parse a function
-sub HeaderFunction($)
-{
-    my($fn) = shift;
-
-    return if ($headerstructs{$fn->{NAME}});
-
-    $headerstructs{$fn->{NAME}} = 1;
-
-    pidl "\nstruct $fn->{NAME} {\n";
-    $tab_depth++;
-    my $needed = 0;
-
-    if (HeaderFunctionInOut_needed($fn, "in")) {
-           pidl tabs()."struct {\n";
-           $tab_depth++;
-           HeaderFunctionInOut($fn, "in");
-           $tab_depth--;
-           pidl tabs()."} in;\n\n";
-           $needed++;
-    }
-
-    if (HeaderFunctionInOut_needed($fn, "out")) {
-           pidl tabs()."struct {\n";
-           $tab_depth++;
-           HeaderFunctionInOut($fn, "out");
-           if ($fn->{RETURN_TYPE} ne "void") {
-                   pidl tabs().mapType($fn->{RETURN_TYPE}) . " result;\n";
-           }
-           $tab_depth--;
-           pidl tabs()."} out;\n\n";
-           $needed++;
-    }
-
-    if (! $needed) {
-           # sigh - some compilers don't like empty structures
-           pidl tabs()."int _dummy_element;\n";
-    }
-
-    $tab_depth--;
-    pidl "};\n\n";
-}
-
 #####################################################################
 # output prototypes for a IDL function
 sub HeaderFnProto($$)
@@ -355,11 +81,6 @@ sub HeaderInterface($)
 {
        my($interface) = shift;
 
-       my $count = 0;
-
-       pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n";
-       pidl "#define _HEADER_NDR_$interface->{NAME}\n\n";
-
        if (defined $interface->{PROPERTIES}->{depends}) {
                my @d = split / /, $interface->{PROPERTIES}->{depends};
                foreach my $i (@d) {
@@ -367,6 +88,11 @@ sub HeaderInterface($)
                }
        }
 
+       my $count = 0;
+
+       pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n";
+       pidl "#define _HEADER_NDR_$interface->{NAME}\n\n";
+
        if (defined $interface->{PROPERTIES}->{uuid}) {
                my $name = uc $interface->{NAME};
                pidl "#define DCERPC_$name\_UUID " . 
@@ -407,20 +133,13 @@ sub HeaderInterface($)
        
        pidl "$count)\n\n";
 
-       foreach my $d (@{$interface->{DATA}}) {
-               next if ($d->{TYPE} ne "CONST");
-               HeaderConst($d);
-       }
-
        foreach my $d (@{$interface->{DATA}}) {
                next if ($d->{TYPE} ne "TYPEDEF");
-               HeaderTypedef($d);
                HeaderTypedefProto($d);
        }
 
        foreach my $d (@{$interface->{DATA}}) {
                next if ($d->{TYPE} ne "FUNCTION");
-               HeaderFunction($d);
                HeaderFnProto($interface, $d);
        }
 
@@ -429,13 +148,15 @@ sub HeaderInterface($)
 
 #####################################################################
 # parse a parsed IDL into a C header
-sub Parse($)
+sub Parse($$)
 {
-    my($idl) = shift;
+    my($idl,$basename) = @_;
     $tab_depth = 0;
 
        $res = "";
-    pidl "/* header auto-generated by pidl */\n\n";
+    pidl "/* header auto-generated by pidl */\n";
+       pidl "#include \"librpc/gen_ndr/$basename\.h\"\n\n";
+
     foreach my $x (@{$idl}) {
            ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
     }
index 85bd2ae8c75e11304dd745b1794f575f3ca46b56..cde96ca0b28acb3261f7cfc36780f927f296abe9 100644 (file)
@@ -2077,6 +2077,8 @@ sub Parse($$)
        pidl "/* parser auto-generated by pidl */";
        pidl "";
        pidl "#include \"includes.h\"";
+       pidl "#include \"librpc/gen_ndr/ndr_misc.h\"";
+       pidl "#include \"librpc/gen_ndr/ndr_dcerpc.h\"";
        pidl "#include \"$h_filename\"";
        pidl "";
 
index 839ef503f37042d1e69321c909ef5f65a10ce1bd..cc0e2b0d32ceb59a29967b6119822b3f541449cf 100755 (executable)
@@ -37,6 +37,7 @@ my($opt_parse) = 0;
 my($opt_dump) = 0;
 my($opt_uint_enums) = 0;
 my($opt_diff) = 0;
+my($opt_header);
 my($opt_ndr_header);
 my($opt_template) = 0;
 my($opt_client);
@@ -70,7 +71,8 @@ Options:
  --parse               parse a idl file to a .pidl file
  --dump                dump a pidl file back to idl
  --uint-enums          don't use C enums, instead use uint* types
- --ndr-header[=OUTFILE]create a C NDR header file
+ --header[=OUTFILE]    create generic header file
+ --ndr-header[=OUTFILE]create a C NDR-specific header file
  --ndr-parser[=OUTFILE]create a C NDR parser
  --ejs[=OUTFILE]       create ejs wrapper file
  --client[=OUTFILE]    create a C NDR client
@@ -99,6 +101,7 @@ GetOptions (
            'dump' => \$opt_dump,
            'uint-enums' => \$opt_uint_enums,
            'ndr-header:s' => \$opt_ndr_header,
+               'header:s' => \$opt_header,
            'server:s' => \$opt_server,
            'template' => \$opt_template,
            'ndr-parser:s' => \$opt_ndr_parser,
@@ -213,10 +216,16 @@ sub process_file($)
                $ndr = Parse::Pidl::NDR::Parse($pidl);
        }
 
+       if (defined($opt_header)) {
+               my $header = ($opt_header or "$outputdir/$basename.h");
+               require Parse::Pidl::Samba::Header;
+               Parse::Pidl::Util::FileSave($header, Parse::Pidl::Samba::Header::Parse($pidl));
+       }
+
        if (defined($opt_ndr_header)) {
                my $header = ($opt_ndr_header or "$outputdir/ndr_$basename.h");
                require Parse::Pidl::Samba::NDR::Header;
-               Parse::Pidl::Util::FileSave($header, Parse::Pidl::Samba::NDR::Header::Parse($pidl));
+               Parse::Pidl::Util::FileSave($header, Parse::Pidl::Samba::NDR::Header::Parse($pidl, $basename));
                if (defined($opt_swig)) {
                  require Parse::Pidl::Samba::SWIG;
                  my($filename) = ($opt_swig or "$outputdir/$basename.i");
index 58799d9b8696654892ccef9f9a22f04c73c952cd..7b6b2014e66c3f77d005fd615b339d01cb4d1509 100644 (file)
@@ -133,10 +133,10 @@ extern int errno;
 #include "byteorder.h"
 #include "module.h"
 #include "librpc/ndr/libndr.h"
-#include "librpc/gen_ndr/ndr_misc.h"
-#include "librpc/gen_ndr/ndr_dcerpc.h"
+#include "librpc/gen_ndr/misc.h"
+#include "librpc/gen_ndr/dcerpc.h"
 #include "librpc/ndr/ndr_orpc.h"
-#include "librpc/gen_ndr/ndr_orpc.h"
+#include "librpc/gen_ndr/orpc.h"
 #include "librpc/rpc/dcerpc.h"
 #include "smb_interfaces.h"
 #include "ntvfs/ntvfs.h"
index 5f232a9fb450ea2b6722d9e3305a75639ead6486..2f899aef45868523f9f904c031643597f4feaa82 100755 (executable)
@@ -6,7 +6,7 @@ PIDL_EXTRA_ARGS="$*"
 
 [ -d librpc/gen_ndr ] || mkdir -p librpc/gen_ndr || exit 1
 
-PIDL="$PERL -Ibuild/pidl ./build/pidl/pidl --outputdir librpc/gen_ndr --parse --ndr-header --ndr-parser --server --client --dcom-proxy --com-header --swig --odl --ejs $PIDL_EXTRA_ARGS"
+PIDL="$PERL -Ibuild/pidl ./build/pidl/pidl --outputdir librpc/gen_ndr --parse --ndr-header --header --ndr-parser --server --client --dcom-proxy --com-header --swig --odl --ejs $PIDL_EXTRA_ARGS"
 
 if [ x$FULLBUILD = xFULL ]; then
       echo Rebuilding all idl files in librpc/idl