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