r16100: Patch from Michael Wood <mwood@icts.uct.ac.za>: s/then/than/ for correct...
[kai/samba.git] / source / 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 =pod
11
12 =head1 NAME
13
14 pidl - An IDL compiler written in Perl
15
16 =head1 SYNOPSIS
17
18 pidl --help
19
20 pidl [--outputdir[=OUTNAME]] [--parse-idl-tree] [--dump-idl-tree] [--dump-ndr-tree] [--header[=OUTPUT]] [--ejs[=OUTPUT]] [--swig[=OUTPUT]] [--uint-enums] [--ndr-parser[=OUTPUT]] [--client] [--server] [--dcom-proxy] [--com-header] [--warn-compat] [--quiet] [--verbose] [--template] [--eth-parser[=OUTPUT]] [--diff] [--dump-idl] [--tdr-parser[=OUTPUT]] [--samba3-header[=OUTPUT]] [--samba3-parser=[OUTPUT]] [--samba3-server=[OUTPUT]] [--samba3-template[=OUTPUT]] [--samba3-client[=OUTPUT]] [--samba3-ndr-client[=OUTPUT]] [<idlfile>.idl]...
21
22 =head1 DESCRIPTION
23
24 pidl is an IDL compiler written in Perl that aims to be somewhat 
25 compatible with the midl compiler. IDL is short for 
26 "Interface Definition Language".
27
28 pidl can generate stubs for DCE/RPC server code, DCE/RPC 
29 client code and ethereal dissectors for DCE/RPC traffic.
30
31 IDL compilers like pidl take a description 
32 of an interface as their input and use it to generate C 
33 (though support for other languages may be added later) code that 
34 can use these interfaces, pretty print data sent 
35 using these interfaces, or even generate ethereal 
36 dissectors that can parse data sent over the 
37 wire by these interfaces. 
38
39 pidl takes IDL files in the same format as is used by midl, 
40 converts it to a .pidl file (which contains pidl's internal representation of the interface) and can then generate whatever output you need.
41 .pidl files should be used for debugging purposes only. Write your 
42 interface definitions in .idl format.
43
44 The goal of pidl is to implement a IDL compiler that can be used 
45 while developing the RPC subsystem in Samba (for 
46 both marshalling/unmarshalling and debugging purposes).
47
48 =head1 OPTIONS
49
50 =over 4
51
52 =item I<--help>
53
54 Show list of available options.
55                 
56 =item I<--outputdir OUTNAME>
57
58 Write output files to the specified directory.  Defaults to the current 
59 directory.
60                 
61 =item I<--parse-idl-tree>
62
63 Read internal tree structure from input files rather 
64 than assuming they contain IDL.
65
66 =item I<--dump-idl>
67
68 Generate a new IDL file. File will be named OUTNAME.idl.
69
70 =item I<--header>
71
72 Generate a C header file for the specified interface. Filename defaults to OUTNAME.h.
73
74 =item I<--ndr-parser>
75
76 Generate a C file and C header containing NDR parsers. The filename for 
77 the parser defaults to ndr_OUTNAME.c. The header filename will be the 
78 parser filename with the extension changed from .c to .h.
79
80 =item I<--tdr-parser>
81
82 Generate a C file and C header containing TDR parsers. The filename for 
83 the parser defaults to tdr_OUTNAME.c. The header filename will be the 
84 parser filename with the extension changed from .c to .h.
85
86 =item I<--server>
87
88 Generate boilerplate for the RPC server that implements 
89 the interface. Filename defaults to ndr_OUTNAME_s.c.
90
91 =item I<--template>
92
93 Generate stubs for a RPC server that implements the interface. Output will 
94 be written to stdout.
95
96 =item I<--eth-parser>
97
98 Generate an Ethereal dissector (in C) and header file. The dissector filename
99 defaults to packet-dcerpc-OUTNAME.c while the header filename defaults to 
100 packet-dcerpc-OUTNAME.h.
101         
102 Pidl will read additional data from an ethereal conformance file if present. 
103 Such a file should have the same location as the IDL file but with the 
104 extension I<cnf> rather than I<idl>. See L<Parse::Pidl::Ethereal::Conformance>
105 for details on the format of this file.
106
107 =item I<--diff>
108
109 Parse an IDL file,  generate a new IDL file based on the internal data 
110 structures and see if there are any differences with the original IDL file. 
111 Useful for debugging pidl.
112
113 =item I<--dump-idl-tree>
114
115 Tell pidl to dump the internal tree representation of an IDL 
116 file the to disk. Useful for debugging pidl.
117
118 =item I<--dump-ndr-tree>
119
120 Tell pidl to dump the internal NDR information tree it generated 
121 from the IDL file to disk.  Useful for debugging pidl.
122
123 =item I<--samba3-header>
124
125 Generate Samba3-style RPC header file. Filename defaults to rpc_BASENAME.h.
126
127 =item I<--samba3-parser>
128
129 Generate parser file for Samba3, to be placed in rpc_parse/. Filename defaults 
130 to parse_BASENAME.c.
131
132 =item I<--samba3-server>
133
134 Generate server file for Samba3, to be placed in rpc_server/. Filename defaults 
135 to srv_BASENAME.c.
136
137 =item I<--samba3-template>
138
139 Generate template for server-side implementation in Samba3, to be placed in 
140 rpc_server/. Filename defaults to srv_BASENAME_nt.c
141
142 =item I<--samba3-client>
143
144 Generate client calls for Samba 3, to be placed in rpc_client/. Filename 
145 defaults to cli_BASENAME.c.
146
147 =item I<--samba3-ndr-client>
148
149 Generate client calls for Samba3, to be placed in rpc_client/. Instead of 
150 calling out to the code in Samba3's rpc_parse/, this will call out to 
151 Samba4's NDR code instead.
152
153 =back
154
155 =head1 IDL SYNTAX
156
157 IDL files are always preprocessed using the C preprocessor.
158
159 Pretty much everything in an interface (the interface itself, functions, 
160 parameters) can have attributes (or properties whatever name you give them). 
161 Attributes always prepend the element they apply to and are surrounded 
162 by square brackets ([]). Multiple attributes are separated by comma's; 
163 arguments to attributes are specified between parentheses. 
164
165 See the section COMPATIBILITY for the list of attributes that 
166 pidl supports.
167
168 C-style comments can be used.
169         
170 =head2 CONFORMANT ARRAYS
171
172 A conformant array is one with that ends in [*] or []. The strange
173 things about conformant arrays are that they can only appear as the last 
174 element of a structure (unless there is a pointer to the conformant array, 
175 of course) and the array size appears before the structure itself on the wire. 
176
177 So, in this example:
178
179         typedef struct {
180                 long abc;
181                 long count;     
182                 long foo;
183                 [size_is(count)] long s[*];
184         } Struct1;
185
186 it appears like this:
187
188         [size_is] [abc] [count] [foo] [s...]
189
190 the first [size_is] field is the allocation size of the array, and
191 occurs before the array elements and even before the structure
192 alignment.
193
194 Note that size_is() can refer to a constant, but that doesn't change
195 the wire representation. It does not make the array a fixed array.
196
197 midl.exe would write the above array as the following C header:
198
199    typedef struct {
200                 long abc;
201                 long count;     
202                 long foo;
203                 long s[1];
204         } Struct1;
205
206 pidl takes a different approach, and writes it like this:
207
208     typedef struct {
209                 long abc;
210                 long count;     
211                 long foo;
212                 long *s;
213         } Struct1;
214
215 =head2 VARYING ARRAYS
216
217 A varying array looks like this:
218
219         typedef struct {
220                 long abc;
221                 long count;     
222                 long foo;
223                 [size_is(count)] long *s;
224         } Struct1;
225
226 This will look like this on the wire:
227
228         [abc] [count] [foo] [PTR_s]    [count] [s...]
229
230 =head2 FIXED ARRAYS
231
232 A fixed array looks like this:
233
234     typedef struct {
235             long s[10];
236     } Struct1;
237
238 The NDR representation looks just like 10 separate long
239 declarations. The array size is not encoded on the wire.
240
241 pidl also supports "inline" arrays, which are not part of the IDL/NDR
242 standard. These are declared like this:
243
244     typedef struct {
245             uint32 foo;
246             uint32 count;
247             uint32 bar;
248             long s[count];
249     } Struct1;
250
251 This appears like this:
252
253         [foo] [count] [bar] [s...]
254
255 Fixed arrays are an extension added to support some of the strange
256 embedded structures in security descriptors and spoolss. 
257
258 This section is by no means complete. See the OpenGroup and MSDN 
259         documentation for additional information.
260
261 =head1 COMPATIBILITY WITH MIDL
262
263 =head2 Missing features in pidl
264
265 The following MIDL features are not (yet) implemented in pidl 
266 or are implemented with an incompatible interface:
267
268 =over
269
270 =item *
271
272 Asynchronous communication
273
274 =item * 
275
276 Typelibs (.tlb files)
277
278 =item *
279
280 Datagram support (ncadg_*)
281
282 =back
283
284 =head2 Supported attributes
285
286 in, out, ref, length_is, switch_is, size_is, uuid, case, default, string, 
287 unique, ptr, pointer_default, v1_enum, object, helpstring, range, local, 
288 call_as, endpoint, switch_type, progid, coclass, iid_is, represent_as, 
289 transmit_as.
290
291 =head2 PIDL Specific properties
292
293 =over 4
294
295 =item public
296
297 The [public] property on a structure or union is a pidl extension that
298 forces the generated pull/push functions to be non-static. This allows
299 you to declare types that can be used between modules. If you don't
300 specify [public] then pull/push functions for other than top-level
301 functions are declared static.
302                                 
303 =item noprint
304
305 The [noprint] property is a pidl extension that allows you to specify
306 that pidl should not generate a ndr_print_*() function for that
307 structure or union. This is used when you wish to define your own
308 print function that prints a structure in a nicer manner. A good
309 example is the use of [noprint] on dom_sid, which allows the
310 pretty-printing of SIDs.
311
312 =item value
313
314 The [value(expression)] property is a pidl extension that allows you
315 to specify the value of a field when it is put on the wire. This
316 allows fields that always have a well-known value to be automatically
317 filled in, thus making the API more programmer friendly. The
318 expression can be any C expression.
319
320 =item relative
321
322 The [relative] property can be supplied on a pointer. When it is used
323 it declares the pointer as a spoolss style "relative" pointer, which
324 means it appears on the wire as an offset within the current
325 encapsulating structure. This is not part of normal IDL/NDR, but it is
326 a very useful extension as it avoids the manual encoding of many
327 complex structures.
328
329 =item subcontext(length)
330
331 Specifies that a size of I<length>
332 bytes should be read, followed by a blob of that size, 
333 which will be parsed as NDR.
334
335 =item flag
336
337 Specify boolean options, mostly used for 
338 low-level NDR options. Several options 
339 can be specified using the | character.
340 Note that flags are inherited by substructures!
341
342 =item nodiscriminant
343
344 The [nodiscriminant] property on a union means that the usual uint16
345 discriminent field at the start of the union on the wire is
346 omitted. This is not normally allowed in IDL/NDR, but is used for some
347 spoolss structures.
348
349 =item charset(name)
350
351 Specify that the array or string uses the specified 
352 charset. If this attribute is specified, pidl will 
353 take care of converting the character data from this format 
354 to the host format. Commonly used values are UCS2, DOS and UTF8.
355
356 =back
357
358 =head2 Unsupported MIDL properties
359
360 aggregatable, appobject, async_uuid, bindable, control, cpp_quote, 
361 defaultbind, defaultcollelem, defaultvalue, defaultvtable, dispinterface, 
362 displaybind, dual, entry, first_is, helpcontext, helpfile, helpstringcontext, 
363 helpstringdll, hidden, idl_module, idl_quote, id, immediatebind, importlib, 
364 import, include, includelib, last_is, lcid, licensed, max_is, module, 
365 ms_union, no_injected_text, nonbrowsable, noncreatable, nonextensible, odl, 
366 oleautomation, optional, pragma, propget, propputref, propput, readonly, 
367 requestedit, restricted, retval, source, uidefault, 
368 usesgetlasterror, vararg, vi_progid, wire_marshal. 
369
370 =head1 EXAMPLES
371
372         # Generating an ethereal parser
373         $ ./pidl --eth-parser -- atsvc.idl
374         
375         # Generating a TDR parser and header
376         $ ./pidl --tdr-parser --header -- regf.idl
377
378         # Generating a Samba3 parser, client and server
379         $ ./pidl --samba3-parser --samba3-server --samba3-client -- dfs.idl
380
381         # Generating a Samba4 NDR parser, client and server
382         $ ./pidl --ndr-parser --ndr-client --ndr-server -- samr.idl
383
384 =head1 SEE ALSO
385
386 L<http://msdn.microsoft.com/library/en-us/rpc/rpc/field_attributes.asp>,
387 L<http://wiki.ethereal.com/DCE/RPC>, 
388 L<http://www.samba.org/>,
389 L<yapp(1)>
390
391 =head1 LICENSE
392
393 pidl is licensed under the GNU General Public License L<http://www.gnu.org/licenses/gpl.html>.
394
395 =head1 AUTHOR
396
397 pidl was written by Andrew Tridgell, Stefan Metzmacher, Tim Potter and Jelmer 
398 Vernooij. The current maintainer is Jelmer Vernooij.
399
400 This manpage was written by Jelmer Vernooij, partially based on the original 
401 pidl README by Andrew Tridgell. 
402         
403 =cut
404
405
406 use strict;
407 use FindBin qw($RealBin);
408 use lib "$RealBin";
409 use lib "$RealBin/lib";
410 use Getopt::Long;
411 use File::Basename;
412 use Parse::Pidl;
413 use Parse::Pidl::Util;
414 use Parse::Pidl::ODL;
415
416 #####################################################################
417 # save a data structure into a file
418 sub SaveStructure($$)
419 {
420         my($filename,$v) = @_;
421         FileSave($filename, Parse::Pidl::Util::MyDumper($v));
422 }
423
424 #####################################################################
425 # load a data structure from a file (as saved with SaveStructure)
426 sub LoadStructure($)
427 {
428         my $f = shift;
429         my $contents = FileLoad($f);
430         defined $contents || return undef;
431         return eval "$contents";
432 }
433
434 #####################################################################
435 # read a file into a string
436 sub FileLoad($)
437 {
438     my($filename) = shift;
439     local(*INPUTFILE);
440     open(INPUTFILE, $filename) || return undef;
441     my($saved_delim) = $/;
442     undef $/;
443     my($data) = <INPUTFILE>;
444     close(INPUTFILE);
445     $/ = $saved_delim;
446     return $data;
447 }
448
449 #####################################################################
450 # write a string into a file
451 sub FileSave($$)
452 {
453     my($filename) = shift;
454     my($v) = shift;
455     local(*FILE);
456     open(FILE, ">$filename") || die "can't open $filename";    
457     print FILE $v;
458     close(FILE);
459 }
460
461 my($opt_help) = 0;
462 my($opt_parse_idl_tree) = 0;
463 my($opt_dump_idl_tree);
464 my($opt_dump_ndr_tree);
465 my($opt_dump_idl) = 0;
466 my($opt_uint_enums) = 0;
467 my($opt_diff) = 0;
468 my($opt_header);
469 my($opt_samba3_header);
470 my($opt_samba3_parser);
471 my($opt_samba3_server);
472 my($opt_samba3_template);
473 my($opt_samba3_client);
474 my($opt_samba3_ndr_client);
475 my($opt_template) = 0;
476 my($opt_client);
477 my($opt_server);
478 my($opt_ndr_parser);
479 my($opt_tdr_parser);
480 my($opt_eth_parser);
481 my($opt_swig);
482 my($opt_dcom_proxy);
483 my($opt_com_header);
484 my($opt_ejs);
485 my($opt_quiet) = 0;
486 my($opt_outputdir) = '.';
487 my($opt_verbose) = 0;
488 my($opt_warn_compat) = 0;
489
490 #########################################
491 # display help text
492 sub ShowHelp()
493 {
494 print "perl IDL parser and code generator
495 Copyright (C) Andrew Tridgell <tridge\@samba.org>
496 Copyright (C) Jelmer Vernooij <jelmer\@samba.org>
497
498 Usage: pidl [options] [--] <idlfile> [<idlfile>...]
499
500 Generic Options:
501  --help                  this help page
502  --outputdir=OUTDIR      put output in OUTDIR/ [.]
503  --warn-compat           warn about incompatibility with other compilers
504  --quiet                 be quiet
505  --verbose               be verbose
506
507 Debugging:
508  --dump-idl-tree[=FILE]  dump internal representation to file [BASENAME.pidl]
509  --parse-idl-tree        read internal representation instead of IDL
510  --dump-ndr-tree[=FILE]  dump internal NDR data tree to file [BASENAME.ndr]
511  --dump-idl              regenerate IDL file
512  --diff                  run diff on original IDL and dumped output
513
514 Samba 4 output:
515  --header[=OUTFILE]      create generic header file [BASENAME.h]
516  --uint-enums            don't use C enums, instead use uint* types
517  --ndr-parser[=OUTFILE]  create a C NDR parser [ndr_BASENAME.c]
518  --client[=OUTFILE]      create a C NDR client [ndr_BASENAME_c.c]
519  --tdr-parser[=OUTFILE]  create a C TDR parser [tdr_BASENAME.c]
520  --ejs[=OUTFILE]         create ejs wrapper file [BASENAME_ejs.c]
521  --swig[=OUTFILE]        create swig wrapper file [BASENAME.i]
522  --server[=OUTFILE]      create server boilerplate [ndr_BASENAME_s.c]
523  --template              print a template for a pipe
524  --dcom-proxy[=OUTFILE]  create DCOM proxy [ndr_BASENAME_p.c]
525  --com-header[=OUTFILE]  create header for COM [com_BASENAME.h]
526
527 Samba 3 output:
528  --samba3-header[=OUTF]  create Samba3-style header [rpc_BASENAME.h]
529  --samba3-parser[=OUTF]  create parser for Samba3 [parse_BASENAME.c]
530  --samba3-template[=OUTF]create template implementation [srv_BASENAME_nt.c]
531  --samba3-server[=OUTF]  create server side wrappers for Samba3 [srv_BASENAME.c]
532  --samba3-client[=OUTF]  create client calls for Samba3 [cli_BASENAME.c]
533  --samba3-ndr-client[=OUTF] create client calls for Samba3 
534                             using Samba4's NDR code [cli_BASENAME.c]
535
536 Ethereal parsers:
537  --eth-parser[=OUTFILE]  create ethereal parser and header
538 \n";
539     exit(0);
540 }
541
542 # main program
543 my $result = GetOptions (
544             'help|h|?' => \$opt_help, 
545             'outputdir=s' => \$opt_outputdir,
546             'dump-idl' => \$opt_dump_idl,
547                 'dump-idl-tree:s' => \$opt_dump_idl_tree,
548                 'parse-idl-tree' => \$opt_parse_idl_tree,
549                 'dump-ndr-tree:s' => \$opt_dump_ndr_tree,
550             'uint-enums' => \$opt_uint_enums,
551                 'samba3-header:s' => \$opt_samba3_header,
552                 'samba3-parser:s' => \$opt_samba3_parser,
553                 'samba3-server:s' => \$opt_samba3_server,
554                 'samba3-template:s' => \$opt_samba3_template,
555                 'samba3-client:s' => \$opt_samba3_client,
556                 'samba3-ndr-client:s' => \$opt_samba3_ndr_client,
557                 'header:s' => \$opt_header,
558             'server:s' => \$opt_server,
559             'tdr-parser:s' => \$opt_tdr_parser,
560             'template' => \$opt_template,
561             'ndr-parser:s' => \$opt_ndr_parser,
562             'client:s' => \$opt_client,
563             'eth-parser:s' => \$opt_eth_parser,
564             'ejs' => \$opt_ejs,
565             'diff' => \$opt_diff,
566             'swig:s' => \$opt_swig,
567             'dcom-proxy:s' => \$opt_dcom_proxy,
568             'com-header:s' => \$opt_com_header,
569             'quiet' => \$opt_quiet,
570                 'verbose' => \$opt_verbose,
571             'warn-compat' => \$opt_warn_compat
572             );
573
574 if (not $result) {
575         exit(1);
576 }
577
578 if ($opt_help) {
579     ShowHelp();
580     exit(0);
581 }
582
583 if ($opt_samba3_client and $opt_samba3_ndr_client) {
584         print "--samba3-client and --samba3-ndr-client can not be used together\n";
585         exit(1);
586 }
587
588 sub process_file($)
589 {
590         my $idl_file = shift;
591         my $outputdir = $opt_outputdir;
592         my $pidl;
593         my $ndr;
594
595         my $basename = basename($idl_file, ".idl");
596
597         unless ($opt_quiet) { print "Compiling $idl_file\n"; }
598
599         if ($opt_parse_idl_tree) {
600                 $pidl = LoadStructure($idl_file);
601                 defined $pidl || die "Failed to load $idl_file";
602         } else {
603                 require Parse::Pidl::IDL;
604
605                 $pidl = Parse::Pidl::IDL::parse_file($idl_file);
606                 defined @$pidl || die "Failed to parse $idl_file";
607                 require Parse::Pidl::Typelist;
608                 Parse::Pidl::Typelist::LoadIdl($pidl);
609         }
610         
611         if (defined($opt_dump_idl_tree)) {
612                 my($pidl_file) = ($opt_dump_idl_tree or "$outputdir/$basename.pidl");
613                 SaveStructure($pidl_file, $pidl) or die "Failed to save $pidl_file\n";
614         }
615
616         if ($opt_uint_enums) {
617                 Parse::Pidl::Util::setUseUintEnums(1);
618         }
619
620         if ($opt_dump_idl) {
621                 require Parse::Pidl::Dump;
622                 print Parse::Pidl::Dump($pidl);
623         }
624
625         if ($opt_diff) {
626                 my($tempfile) = "$outputdir/$basename.tmp";
627                 FileSave($tempfile, IdlDump::Dump($pidl));
628                 system("diff -wu $idl_file $tempfile");
629                 unlink($tempfile);
630         }
631
632
633         my $comh_filename = ($opt_com_header or "$outputdir/com_$basename.h");
634         if (defined($opt_com_header)) {
635                 require Parse::Pidl::Samba4::COM::Header;
636                 my $res = Parse::Pidl::Samba4::COM::Header::Parse($pidl,"$outputdir/ndr_$basename.h");
637                 if ($res) {
638                         FileSave($comh_filename, $res);
639                 }
640         }
641
642         if (defined($opt_dcom_proxy)) {
643                 require Parse::Pidl::Samba4::COM::Proxy;
644                 my $res = Parse::Pidl::Samba4::COM::Proxy::Parse($pidl,$comh_filename);
645                 if ($res) {
646                         my ($client) = ($opt_dcom_proxy or "$outputdir/$basename\_p.c");
647                         FileSave($client, $res);
648                 }
649         }
650
651         if ($opt_warn_compat) {
652                 require Parse::Pidl::Compat;
653                 Parse::Pidl::Compat::Check($pidl);
654         }
655
656         $pidl = Parse::Pidl::ODL::ODL2IDL($pidl);
657
658         if (defined($opt_eth_parser) or 
659             defined($opt_client) or defined($opt_server) or 
660             defined($opt_ndr_parser) or defined($opt_ejs) or 
661                 defined($opt_dump_ndr_tree) or defined($opt_samba3_header) or 
662             defined($opt_samba3_parser) or defined($opt_samba3_server) or 
663                 defined($opt_samba3_template) or defined($opt_samba3_client) or
664                 defined($opt_swig) or defined($opt_samba3_ndr_client)) {
665                 require Parse::Pidl::NDR;
666                 $ndr = Parse::Pidl::NDR::Parse($pidl);
667         }
668
669         if (defined($opt_dump_ndr_tree)) {
670                 my($ndr_file) = ($opt_dump_ndr_tree or "$outputdir/$basename.ndr");
671                 SaveStructure($ndr_file, $ndr) or die "Failed to save $ndr_file\n";
672         }
673
674         my $gen_header = ($opt_header or "$outputdir/$basename.h");
675         if (defined($opt_header)) {
676                 require Parse::Pidl::Samba4::Header;
677                 FileSave($gen_header, Parse::Pidl::Samba4::Header::Parse($pidl));
678         }
679
680         my $h_filename = "$outputdir/ndr_$basename.h";
681         if (defined($opt_client)) {
682                 require Parse::Pidl::Samba4::NDR::Client;
683                 my ($c_client) = ($opt_client or "$outputdir/ndr_$basename\_c.c");
684                 my ($c_header) = $c_client;
685                 $c_header =~ s/\.c$/.h/;
686
687                 my ($srcd,$hdrd) = Parse::Pidl::Samba4::NDR::Client::Parse(
688                         $ndr,$gen_header,$h_filename,$c_header);
689
690                 FileSave($c_client, $srcd);
691                 FileSave($c_header, $hdrd);
692         }
693
694         if (defined($opt_swig)) {
695                   require Parse::Pidl::Samba4::SWIG;
696                   my($filename) = ($opt_swig or "$outputdir/$basename.i");
697                   my $code = Parse::Pidl::Samba4::SWIG::Parse($ndr, $basename, "$outputdir/ndr_$basename\_c.h", $gen_header);
698                   FileSave($filename, $code);
699         }
700
701         if (defined($opt_ejs)) {
702                 require Parse::Pidl::Samba4::EJS;
703                 my ($hdr,$prsr) = Parse::Pidl::Samba4::EJS::Parse($ndr, $h_filename);
704                 FileSave("$outputdir/ndr_$basename\_ejs.c", $prsr);
705                 FileSave("$outputdir/ndr_$basename\_ejs.h", $hdr);
706         }
707
708         if (defined($opt_server)) {
709                 require Parse::Pidl::Samba4::NDR::Server;
710                 my $dcom = "";
711
712                 foreach (@{$pidl}) {
713                         next if ($_->{TYPE} ne "INTERFACE");
714
715                         if (Parse::Pidl::Util::has_property($_, "object")) {
716                                 require Parse::Pidl::Samba4::COM::Stub;
717                                 $dcom .= Parse::Pidl::Samba4::COM::Stub::ParseInterface($_);
718                         }
719                 }
720
721                 FileSave(($opt_server or "$outputdir/ndr_$basename\_s.c"), Parse::Pidl::Samba4::NDR::Server::Parse($ndr,$h_filename));
722
723                 if ($dcom ne "") {
724                         $dcom = "
725 #include \"includes.h\"
726 #include \"$h_filename\"
727 #include \"rpc_server/dcerpc_server.h\"
728 #include \"rpc_server/common/common.h\"
729
730 $dcom
731 ";
732         FileSave("$outputdir/$basename\_d.c", $dcom);
733                 }
734         }
735
736         if (defined($opt_ndr_parser)) {
737                 my $parser_fname = ($opt_ndr_parser or "$outputdir/ndr_$basename.c");
738                 require Parse::Pidl::Samba4::NDR::Parser;
739                 my ($header,$parser) = Parse::Pidl::Samba4::NDR::Parser::Parse($ndr, $gen_header, $h_filename);
740
741
742                 FileSave($parser_fname, $parser);
743                 FileSave($h_filename, $header);
744
745         }
746
747         if (defined($opt_eth_parser)) {
748           require Parse::Pidl::Ethereal::NDR;
749           my($eparser) = ($opt_eth_parser or "$outputdir/packet-dcerpc-$basename.c");
750           my $eheader = $eparser;
751           $eheader =~ s/\.c$/\.h/;
752           my $cnffile = $idl_file;
753           $cnffile =~ s/\.idl$/\.cnf/;
754
755           my ($dp, $dh) = Parse::Pidl::Ethereal::NDR::Parse($ndr, $idl_file, $eheader, $cnffile);
756           FileSave($eparser, $dp) if defined($dp);
757           FileSave($eheader, $dh) if defined($dh);
758         }
759
760         if (defined($opt_tdr_parser)) {
761                 my $tdr_parser = ($opt_tdr_parser or "$outputdir/tdr_$basename.c");
762                 my $tdr_header = $tdr_parser;
763                 $tdr_header =~ s/\.c$/\.h/;
764                 require Parse::Pidl::Samba4::TDR;
765                 my ($hdr,$prsr) = Parse::Pidl::Samba4::TDR::Parser($pidl, $tdr_header, $gen_header);
766                 FileSave($tdr_parser, $prsr);
767                 FileSave($tdr_header, $hdr);
768         }
769
770         if ($opt_template) {
771                 require Parse::Pidl::Samba4::Template;
772                 print Parse::Pidl::Samba4::Template::Parse($pidl);
773         }
774
775         if (defined($opt_samba3_header) or defined($opt_samba3_parser) or
776                 defined($opt_samba3_server) or defined($opt_samba3_client) or
777                 defined($opt_samba3_ndr_client) or defined($opt_samba3_template)) {
778                 require Parse::Pidl::Samba3::Types;
779                 Parse::Pidl::Samba3::Types::LoadTypes($ndr);
780         }
781
782         if (defined($opt_samba3_header)) {
783                 my $header = ($opt_samba3_header or "$outputdir/rpc_$basename.h");
784                 require Parse::Pidl::Samba3::Header;
785                 FileSave($header, Parse::Pidl::Samba3::Header::Parse($ndr, $basename));
786         }
787
788         if (defined($opt_samba3_parser)) {
789                 my $header = ($opt_samba3_parser or "$outputdir/parse_$basename.c");
790                 require Parse::Pidl::Samba3::Parser;
791                 FileSave($header, Parse::Pidl::Samba3::Parser::Parse($ndr, $basename));
792         }
793
794         if (defined($opt_samba3_server)) {
795                 my $header = ($opt_samba3_server or "$outputdir/srv_$basename.c");
796                 require Parse::Pidl::Samba3::Server;
797                 FileSave($header, Parse::Pidl::Samba3::Server::Parse($ndr, $basename));
798         }
799
800         if (defined($opt_samba3_template)) {
801                 my $header = ($opt_samba3_template or "$outputdir/srv_$basename\_nt.c");
802                 require Parse::Pidl::Samba3::Template;
803                 FileSave($header, Parse::Pidl::Samba3::Template::Parse($ndr, $basename));
804         }
805
806         if (defined($opt_samba3_client)) {
807                 my $header = ($opt_samba3_client or "$outputdir/cli_$basename.c");
808                 require Parse::Pidl::Samba3::Client;
809                 FileSave($header, Parse::Pidl::Samba3::Client::Parse($ndr, $basename));
810         }
811
812         if (defined($opt_samba3_ndr_client)) {
813                 my $client = ($opt_samba3_ndr_client or "$outputdir/cli_$basename.c");
814                 my $header = $client; $header =~ s/\.c$/\.h/;
815                 require Parse::Pidl::Samba3::ClientNDR;
816                 my ($c_code,$h_code) = Parse::Pidl::Samba3::ClientNDR::Parse($ndr, $header, $h_filename);
817                 FileSave($client, $c_code);
818                 FileSave($header, $h_code);
819         }
820
821
822 }
823
824 if (scalar(@ARGV) == 0) {
825         print "pidl: no input files\n";
826         exit(1);
827 }
828
829 process_file($_) foreach (@ARGV);