699497549a780acbe58ba86ea2bebc57a1f0a629
[sfrench/samba-autobuild/.git] / source / build / pidl / pidl
1 #!/usr/bin/perl -w
2
3 ###################################################
4 # package to parse IDL files and generate code for
5 # rpc functions in Samba
6 # Copyright tridge@samba.org 2000-2003
7 # Copyright jelmer@samba.org 2005
8 # released under the GNU GPL
9
10 use strict;
11
12 use Getopt::Long;
13 use File::Basename;
14 use Parse::Pidl;
15 use Parse::Pidl::Util;
16
17 #####################################################################
18 # save a data structure into a file
19 sub SaveStructure($$)
20 {
21         my($filename,$v) = @_;
22         FileSave($filename, Parse::Pidl::Util::MyDumper($v));
23 }
24
25 #####################################################################
26 # load a data structure from a file (as saved with SaveStructure)
27 sub LoadStructure($)
28 {
29         my $f = shift;
30         my $contents = FileLoad($f);
31         defined $contents || return undef;
32         return eval "$contents";
33 }
34
35 #####################################################################
36 # read a file into a string
37 sub FileLoad($)
38 {
39     my($filename) = shift;
40     local(*INPUTFILE);
41     open(INPUTFILE, $filename) || return undef;
42     my($saved_delim) = $/;
43     undef $/;
44     my($data) = <INPUTFILE>;
45     close(INPUTFILE);
46     $/ = $saved_delim;
47     return $data;
48 }
49
50 #####################################################################
51 # write a string into a file
52 sub FileSave($$)
53 {
54     my($filename) = shift;
55     my($v) = shift;
56     local(*FILE);
57     open(FILE, ">$filename") || die "can't open $filename";    
58     print FILE $v;
59     close(FILE);
60 }
61
62
63
64 my($opt_help) = 0;
65 my($opt_parse) = 0;
66 my($opt_dump) = 0;
67 my($opt_uint_enums) = 0;
68 my($opt_diff) = 0;
69 my($opt_header);
70 my($opt_ndr_header);
71 my($opt_template) = 0;
72 my($opt_client);
73 my($opt_server);
74 my($opt_ndr_parser);
75 my($opt_tdr_header);
76 my($opt_tdr_parser);
77 my($opt_eth_parser);
78 my($opt_eth_header);
79 my($opt_keep);
80 my($opt_swig);
81 my($opt_dcom_proxy);
82 my($opt_com_header);
83 my($opt_ejs);
84 my($opt_odl) = 0;
85 my($opt_quiet) = 0;
86 my($opt_outputdir) = '.';
87 my($opt_verbose) = 0;
88 my($opt_warn_compat) = 0;
89
90 #########################################
91 # display help text
92 sub ShowHelp()
93 {
94 print "perl IDL parser and code generator
95 Copyright (C) tridge\@samba.org
96
97 Usage: pidl [options] <idlfile>
98
99 Options:
100  --help                this help page
101  --outputdir=OUTDIR    put output in OUTDIR/ [.]
102  --parse               parse a idl file to a .pidl file
103  --dump                dump a pidl file back to idl
104  --uint-enums          don't use C enums, instead use uint* types
105  --header[=OUTFILE]    create generic header file
106  --ndr-header[=OUTFILE]create a C NDR-specific header file
107  --ndr-parser[=OUTFILE]create a C NDR parser
108  --tdr-header[=OUTFILE]create a C TDR header file
109  --tdr-parser[=OUTFILE]create a C TDR parser
110  --ejs[=OUTFILE]       create ejs wrapper file
111  --client[=OUTFILE]    create a C NDR client
112  --server[=OUTFILE]    create server boilerplate
113  --template            print a template for a pipe
114  --eth-parser[=OUTFILE]create an ethereal parser
115  --eth-header[=OUTFILE]create an ethereal header file
116  --swig[=OUTFILE]      create swig wrapper file
117  --diff                run diff on the idl and dumped output
118  --keep[=OUTFILE]      keep the .pidl file
119  --odl                 accept ODL input
120  --dcom-proxy[=OUTFILE]create DCOM proxy (implies --odl)
121  --com-header[=OUTFILE]create header for COM interfaces (implies --odl)
122  --warn-compat         warn about incompatibility with other compilers
123  --quiet               be quiet
124  --verbose             be verbose
125 \n";
126     exit(0);
127 }
128
129 # main program
130 GetOptions (
131             'help|h|?' => \$opt_help, 
132             'outputdir=s' => \$opt_outputdir,
133             'parse' => \$opt_parse,
134             'dump' => \$opt_dump,
135             'uint-enums' => \$opt_uint_enums,
136             'ndr-header:s' => \$opt_ndr_header,
137                 'header:s' => \$opt_header,
138             'server:s' => \$opt_server,
139             'tdr-header:s' => \$opt_tdr_header,
140             'tdr-parser:s' => \$opt_tdr_parser,
141             'template' => \$opt_template,
142             'ndr-parser:s' => \$opt_ndr_parser,
143             'client:s' => \$opt_client,
144             'eth-parser:s' => \$opt_eth_parser,
145             'eth-header:s' => \$opt_eth_header,
146             'ejs' => \$opt_ejs,
147             'diff' => \$opt_diff,
148             'odl' => \$opt_odl,
149             'keep:s' => \$opt_keep,
150             'swig:s' => \$opt_swig,
151             'dcom-proxy:s' => \$opt_dcom_proxy,
152             'com-header:s' => \$opt_com_header,
153             'quiet' => \$opt_quiet,
154                 'verbose' => \$opt_verbose,
155             'warn-compat' => \$opt_warn_compat
156             );
157
158 if ($opt_help) {
159     ShowHelp();
160     exit(0);
161 }
162
163 sub process_file($)
164 {
165         my $idl_file = shift;
166         my $outputdir = $opt_outputdir;
167         my $pidl;
168         my $ndr;
169
170         my $basename = basename($idl_file, ".idl");
171
172         my($pidl_file) = ($opt_keep or "$outputdir/$basename.pidl");
173
174         unless ($opt_quiet) { print "Compiling $idl_file\n"; }
175
176         if ($opt_parse) {
177                 require Parse::Pidl::IDL;
178                 my $idl_parser = new Parse::Pidl::IDL;
179
180                 $pidl = $idl_parser->parse_idl($idl_file);
181                 defined @$pidl || die "Failed to parse $idl_file";
182                 require Parse::Pidl::Typelist;
183                 Parse::Pidl::Typelist::LoadIdl($pidl);
184                 if (defined($opt_keep) && !SaveStructure($pidl_file, $pidl)) {
185                             die "Failed to save $pidl_file\n";
186                 }
187         } else {
188                 $pidl = LoadStructure($pidl_file);
189                 defined $pidl || die "Failed to load $pidl_file - maybe you need --parse\n";
190         }
191
192         if ($opt_uint_enums) {
193                 Parse::Pidl::Util::setUseUintEnums(1);
194         }
195
196         if ($opt_dump) {
197                 require Parse::Pidl::Dump;
198                 print Parse::Pidl::Dump($pidl);
199         }
200
201         if ($opt_diff) {
202                 my($tempfile) = "$outputdir/$basename.tmp";
203                 FileSave($tempfile, IdlDump::Dump($pidl));
204                 system("diff -wu $idl_file $tempfile");
205                 unlink($tempfile);
206         }
207
208         if (defined($opt_com_header)) {
209                 require Parse::Pidl::Samba::COM::Header;
210                 my $res = Parse::Pidl::Samba::COM::Header::Parse($pidl);
211                 if ($res) {
212                         my $comh_filename = ($opt_com_header or "$outputdir/com_$basename.h");
213                         FileSave($comh_filename, 
214                         "#include \"librpc/gen_ndr/ndr_orpc.h\"\n" . 
215                         "#include \"$outputdir/ndr_$basename.h\"\n" . 
216                         $res);
217                 }
218                 $opt_odl = 1;
219         }
220
221         if (defined($opt_dcom_proxy)) {
222                 require Parse::Pidl::Samba::COM::Proxy;
223                 my $res = Parse::Pidl::Samba::COM::Proxy::Parse($pidl);
224                 if ($res) {
225                         my ($client) = ($opt_dcom_proxy or "$outputdir/$basename\_p.c");
226                         FileSave($client, 
227                         "#include \"includes.h\"\n" .
228                         "#include \"$outputdir/com_$basename.h\"\n" . 
229                         "#include \"lib/com/dcom/dcom.h\"\n" .$res);
230                 }
231                 $opt_odl = 1;
232         }
233
234         if ($opt_warn_compat) {
235                 require Parse::Pidl::Compat;
236                 Parse::Pidl::Compat::Check($pidl);
237         }
238
239         if ($opt_odl) {
240                 require Parse::Pidl::ODL;
241                 $pidl = Parse::Pidl::ODL::ODL2IDL($pidl);
242         }
243
244         if (defined($opt_ndr_header) or defined($opt_eth_parser) or 
245             defined($opt_eth_header) or defined($opt_client) or 
246             defined($opt_server) or defined($opt_ndr_parser) or 
247             defined($opt_ejs)) {
248                 require Parse::Pidl::NDR;
249                 Parse::Pidl::NDR::Validate($pidl);
250                 $ndr = Parse::Pidl::NDR::Parse($pidl);
251         }
252
253         if (defined($opt_header)) {
254                 my $header = ($opt_header or "$outputdir/$basename.h");
255                 require Parse::Pidl::Samba::Header;
256                 FileSave($header, Parse::Pidl::Samba::Header::Parse($pidl));
257         }
258
259         if (defined($opt_ndr_header)) {
260                 my $header = ($opt_ndr_header or "$outputdir/ndr_$basename.h");
261                 require Parse::Pidl::Samba::NDR::Header;
262                 FileSave($header, Parse::Pidl::Samba::NDR::Header::Parse($pidl, $basename));
263                 if (defined($opt_swig)) {
264                   require Parse::Pidl::Samba::SWIG;
265                   my($filename) = ($opt_swig or "$outputdir/$basename.i");
266                   Parse::Pidl::Samba::SWIG::RewriteHeader($pidl, $header, $filename);
267                 }
268         }
269
270         if (defined($opt_eth_header)) {
271           require Parse::Pidl::Ethereal::NDR::Header;
272           my($eparserhdr) = ($opt_eth_header or "$outputdir/packet-dcerpc-$basename.h");
273
274           FileSave($eparserhdr, Parse::Pidl::Ethereal::NDR::Header::Parse($ndr));
275         }
276
277         my $h_filename = "$outputdir/ndr_$basename.h";
278         if (defined($opt_client)) {
279                 require Parse::Pidl::Samba::NDR::Client;
280                 my ($client) = ($opt_client or "$outputdir/ndr_$basename\_c.c");
281
282                 FileSave($client, Parse::Pidl::Samba::NDR::Client::Parse($ndr,$h_filename));
283         }
284
285         if (defined($opt_ejs)) {
286                 require Parse::Pidl::Samba::EJS;
287                 require Parse::Pidl::Samba::EJSHeader;
288                 FileSave("$outputdir/ndr_$basename\_ejs.c", Parse::Pidl::Samba::EJS::Parse($ndr, $h_filename));
289
290                 FileSave("$outputdir/ndr_$basename\_ejs.h", Parse::Pidl::Samba::EJSHeader::Parse($ndr));
291         }
292
293         if (defined($opt_server)) {
294                 require Parse::Pidl::Samba::NDR::Server;
295                 my $dcom = "";
296
297                 foreach my $x (@{$pidl}) {
298                         next if ($x->{TYPE} ne "INTERFACE");
299
300                         if (Parse::Pidl::Util::has_property($x, "object")) {
301                                 require Parse::Pidl::Samba::COM::Stub;
302                                 $dcom .= Parse::Pidl::Samba::COM::Stub::ParseInterface($x);
303                         }
304                 }
305
306                 FileSave(($opt_server or "$outputdir/ndr_$basename\_s.c"), Parse::Pidl::Samba::NDR::Server::Parse($ndr,$h_filename));
307
308                 if ($dcom ne "") {
309                         $dcom = "
310 #include \"includes.h\"
311 #include \"$h_filename\"
312 #include \"rpc_server/dcerpc_server.h\"
313 #include \"rpc_server/common/common.h\"
314
315 $dcom
316 ";
317         FileSave("$outputdir/$basename\_d.c", $dcom);
318                 }
319         }
320
321         if (defined($opt_ndr_parser)) {
322                 my $parser = ($opt_ndr_parser or "$outputdir/ndr_$basename.c");
323                 require Parse::Pidl::Samba::NDR::Parser;
324                 FileSave($parser, Parse::Pidl::Samba::NDR::Parser::Parse($ndr, $parser));
325         }
326
327         if (defined($opt_eth_parser)) {
328           require Parse::Pidl::Ethereal::NDR::Parser;
329           my($eparser) = ($opt_eth_parser or "$outputdir/packet-dcerpc-$basename.c");
330           FileSave($eparser, Parse::Pidl::Ethereal::NDR::Parser::Parse($ndr, $basename, $eparser));
331         }
332
333         my $tdr_parser = ($opt_tdr_parser or "$outputdir/tdr_$basename.c");
334         my $tdr_header = ($opt_tdr_header or "$outputdir/tdr_$basename.h");
335         if (defined($opt_tdr_parser)) {
336                 require Parse::Pidl::Samba::TDR;
337                 FileSave($tdr_parser, Parse::Pidl::Samba::TDR::Parser($pidl, $tdr_header));
338         }
339
340         if (defined($opt_tdr_header)) {
341                 require Parse::Pidl::Samba::TDR;
342                 FileSave($tdr_header, Parse::Pidl::Samba::TDR::Header($pidl, $outputdir));
343         }
344
345         if ($opt_template) {
346                 require Parse::Pidl::Samba::Template;
347                 print Parse::Pidl::Samba::Template::Parse($pidl);
348         }
349 }
350
351 foreach my $filename (@ARGV) {
352         process_file($filename);
353 }