Update dcerpc_server.pc library name to match reality.
[kai/samba.git] / pidl / idl.yp
1 ########################
2 # IDL Parse::Yapp parser
3 # Copyright (C) Andrew Tridgell <tridge@samba.org>
4 # released under the GNU GPL version 3 or later
5
6
7
8 # the precedence actually doesn't matter at all for this grammar, but
9 # by providing a precedence we reduce the number of conflicts
10 # enormously
11 %left   '-' '+' '&' '|' '*' '>' '.' '/' '(' ')' '[' ',' ';'
12
13
14 ################
15 # grammar
16 %%
17 idl: 
18         #empty  { {} }
19         |
20         idl interface { push(@{$_[1]}, $_[2]); $_[1] }
21         |
22         idl coclass   { push(@{$_[1]}, $_[2]); $_[1] }
23         |
24         idl import    { push(@{$_[1]}, $_[2]); $_[1] }
25         |
26         idl include   { push(@{$_[1]}, $_[2]); $_[1] }
27         |
28         idl importlib { push(@{$_[1]}, $_[2]); $_[1] }
29         |
30         idl cpp_quote { push(@{$_[1]}, $_[2]); $_[1] }
31 ;
32
33 import:
34         'import' commalist ';'
35         {{
36                 "TYPE" => "IMPORT",
37                 "PATHS" => $_[2],
38                 "FILE" => $_[0]->YYData->{FILE},
39                 "LINE" => $_[0]->YYData->{LINE},
40         }}
41 ;
42
43 include:
44         'include' commalist ';'
45         {{
46                 "TYPE" => "INCLUDE",
47                 "PATHS" => $_[2],
48                 "FILE" => $_[0]->YYData->{FILE},
49                 "LINE" => $_[0]->YYData->{LINE},
50         }}
51 ;
52
53 importlib:
54         'importlib' commalist ';'
55         {{
56                 "TYPE" => "IMPORTLIB",
57                 "PATHS" => $_[2],
58                 "FILE" => $_[0]->YYData->{FILE},
59                 "LINE" => $_[0]->YYData->{LINE},
60         }}
61 ;
62
63 commalist:
64         text { [ $_[1] ] }
65         |
66         commalist ',' text { push(@{$_[1]}, $_[3]); $_[1] }
67 ;
68
69 coclass:
70         property_list 'coclass' identifier '{' interface_names '}' optional_semicolon
71         {{
72                 "TYPE" => "COCLASS",
73                 "PROPERTIES" => $_[1],
74                 "NAME" => $_[3],
75                 "DATA" => $_[5],
76                 "FILE" => $_[0]->YYData->{FILE},
77                 "LINE" => $_[0]->YYData->{LINE},
78         }}
79 ;
80
81 interface_names:
82         #empty { {} }
83         |
84         interface_names 'interface' identifier ';' { push(@{$_[1]}, $_[2]); $_[1] }
85 ;
86
87 interface:
88         property_list 'interface' identifier base_interface '{' definitions '}' optional_semicolon
89         {{
90                 "TYPE" => "INTERFACE",
91                 "PROPERTIES" => $_[1],
92                 "NAME" => $_[3],
93                 "BASE" => $_[4],
94                 "DATA" => $_[6],
95                 "FILE" => $_[0]->YYData->{FILE},
96                 "LINE" => $_[0]->YYData->{LINE},
97         }}
98 ;
99
100 base_interface:
101         #empty
102         |
103         ':' identifier { $_[2] }
104 ;
105
106
107 cpp_quote:
108         'cpp_quote' '(' text ')'
109         {{
110                  "TYPE" => "CPP_QUOTE",
111                  "DATA" => $_[3],
112                  "FILE" => $_[0]->YYData->{FILE},
113                  "LINE" => $_[0]->YYData->{LINE},
114         }}
115 ;
116
117 definitions:
118         definition              { [ $_[1] ] }
119         |
120         definitions definition  { push(@{$_[1]}, $_[2]); $_[1] }
121 ;
122
123 definition:
124         function
125         |
126         const
127         |
128         typedef
129         |
130         typedecl
131 ;
132
133 const:
134         'const' identifier pointers identifier '=' anytext ';'
135         {{
136                 "TYPE"  => "CONST",
137                 "DTYPE"  => $_[2],
138                 "POINTERS" => $_[3],
139                 "NAME"  => $_[4],
140                 "VALUE" => $_[6],
141                 "FILE" => $_[0]->YYData->{FILE},
142                 "LINE" => $_[0]->YYData->{LINE},
143         }}
144         |
145         'const' identifier pointers identifier array_len '=' anytext ';'
146         {{
147                 "TYPE"  => "CONST",
148                 "DTYPE"  => $_[2],
149                 "POINTERS" => $_[3],
150                 "NAME"  => $_[4],
151                 "ARRAY_LEN" => $_[5],
152                 "VALUE" => $_[7],
153                 "FILE" => $_[0]->YYData->{FILE},
154                 "LINE" => $_[0]->YYData->{LINE},
155         }}
156 ;
157
158 function:
159         property_list type identifier '(' element_list2 ')' ';'
160         {{
161                 "TYPE" => "FUNCTION",
162                 "NAME" => $_[3],
163                 "RETURN_TYPE" => $_[2],
164                 "PROPERTIES" => $_[1],
165                 "ELEMENTS" => $_[5],
166                 "FILE" => $_[0]->YYData->{FILE},
167                 "LINE" => $_[0]->YYData->{LINE},
168         }}
169 ;
170
171 typedef:
172         property_list 'typedef' type pointers identifier array_len ';'
173         {{
174                 "TYPE" => "TYPEDEF",
175                 "PROPERTIES" => $_[1],
176                 "NAME" => $_[5],
177                 "DATA" => $_[3],
178                 "POINTERS" => $_[4],
179                 "ARRAY_LEN" => $_[6],
180                 "FILE" => $_[0]->YYData->{FILE},
181                 "LINE" => $_[0]->YYData->{LINE},
182         }}
183 ;
184
185 usertype:
186         struct
187         |
188         union
189         |
190         enum
191         |
192         bitmap
193         |
194         pipe
195 ;
196
197 typedecl:
198         usertype ';' { $_[1] }
199 ;
200
201 sign:
202         'signed'
203         |
204         'unsigned'
205 ;
206
207 existingtype:
208         sign identifier { ($_[1]?$_[1]:"signed") ." $_[2]" }
209         |
210         identifier
211 ;
212
213 type:
214         usertype
215         |
216         existingtype
217         |
218         void { "void" }
219 ;
220
221 enum_body:
222         '{' enum_elements '}' { $_[2] }
223 ;
224
225 opt_enum_body:
226         #empty
227         |
228         enum_body
229 ;
230
231 enum:
232         property_list 'enum' optional_identifier opt_enum_body
233         {{
234                 "TYPE" => "ENUM",
235                 "PROPERTIES" => $_[1],
236                 "NAME" => $_[3],
237                 "ELEMENTS" => $_[4],
238                 "FILE" => $_[0]->YYData->{FILE},
239                 "LINE" => $_[0]->YYData->{LINE},
240         }}
241 ;
242
243 enum_elements:
244         enum_element                    { [ $_[1] ] }
245         |
246         enum_elements ',' enum_element  { push(@{$_[1]}, $_[3]); $_[1] }
247 ;
248
249 enum_element:
250         identifier
251         |
252         identifier '=' anytext { "$_[1]$_[2]$_[3]" }
253 ;
254
255 bitmap_body:
256         '{' opt_bitmap_elements '}' { $_[2] }
257 ;
258
259 opt_bitmap_body:
260         #empty
261         |
262         bitmap_body
263 ;
264
265 bitmap:
266         property_list 'bitmap' optional_identifier opt_bitmap_body
267         {{
268                 "TYPE" => "BITMAP",
269                 "PROPERTIES" => $_[1],
270                 "NAME" => $_[3],
271                 "ELEMENTS" => $_[4],
272                 "FILE" => $_[0]->YYData->{FILE},
273                 "LINE" => $_[0]->YYData->{LINE},
274         }}
275 ;
276
277 bitmap_elements:
278         bitmap_element                      { [ $_[1] ] }
279         |
280         bitmap_elements ',' bitmap_element  { push(@{$_[1]}, $_[3]); $_[1] }
281 ;
282
283 opt_bitmap_elements:
284         #empty
285         |
286         bitmap_elements
287 ;
288
289 bitmap_element:
290         identifier '=' anytext { "$_[1] ( $_[3] )" }
291 ;
292
293 struct_body:
294         '{' element_list1 '}' { $_[2] }
295 ;
296
297 opt_struct_body:
298         #empty
299         |
300         struct_body
301 ;
302
303 struct:
304         property_list 'struct' optional_identifier opt_struct_body
305         {{
306                 "TYPE" => "STRUCT",
307                 "PROPERTIES" => $_[1],
308                 "NAME" => $_[3],
309                 "ELEMENTS" => $_[4],
310                 "FILE" => $_[0]->YYData->{FILE},
311                 "LINE" => $_[0]->YYData->{LINE},
312         }}
313 ;
314
315 empty_element:
316         property_list ';'
317         {{
318                 "NAME" => "",
319                 "TYPE" => "EMPTY",
320                 "PROPERTIES" => $_[1],
321                 "POINTERS" => 0,
322                 "ARRAY_LEN" => [],
323                 "FILE" => $_[0]->YYData->{FILE},
324                 "LINE" => $_[0]->YYData->{LINE},
325         }}
326 ;
327
328 base_or_empty:
329         base_element ';'
330         |
331         empty_element;
332
333 optional_base_element:
334         property_list base_or_empty { $_[2]->{PROPERTIES} = FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] }
335 ;
336
337 union_elements:
338         #empty
339         |
340         union_elements optional_base_element { push(@{$_[1]}, $_[2]); $_[1] }
341 ;
342
343 union_body:
344         '{' union_elements '}' { $_[2] }
345 ;
346
347 opt_union_body:
348         #empty
349         |
350         union_body
351 ;
352
353 union:
354         property_list 'union' optional_identifier opt_union_body
355         {{
356                 "TYPE" => "UNION",
357                 "PROPERTIES" => $_[1],
358                 "NAME" => $_[3],
359                 "ELEMENTS" => $_[4],
360                 "FILE" => $_[0]->YYData->{FILE},
361                 "LINE" => $_[0]->YYData->{LINE},
362         }}
363 ;
364
365 base_element:
366         property_list type pointers identifier array_len
367         {{
368                 "NAME" => $_[4],
369                 "TYPE" => $_[2],
370                 "PROPERTIES" => $_[1],
371                 "POINTERS" => $_[3],
372                 "ARRAY_LEN" => $_[5],
373                 "FILE" => $_[0]->YYData->{FILE},
374                 "LINE" => $_[0]->YYData->{LINE},
375         }}
376 ;
377
378 pointers:
379         #empty
380         { 0 }
381         |
382         pointers '*'  { $_[1]+1 }
383 ;
384
385 pipe:
386         property_list 'pipe' type
387         {{
388                 "TYPE" => "PIPE",
389                 "PROPERTIES" => $_[1],
390                 "DATA" => $_[3],
391                 "FILE" => $_[0]->YYData->{FILE},
392                 "LINE" => $_[0]->YYData->{LINE},
393         }}
394 ;
395
396 element_list1:
397         #empty
398         { [] }
399         |
400         element_list1 base_element ';' { push(@{$_[1]}, $_[2]); $_[1] }
401 ;
402
403 optional_const:
404         #empty
405         |
406         'const'
407 ;
408
409 element_list2:
410         #empty
411         |
412         'void'
413         |
414         optional_const base_element { [ $_[2] ] }
415         |
416         element_list2 ',' optional_const base_element { push(@{$_[1]}, $_[4]); $_[1] }
417 ;
418
419 array_len:
420         #empty { [] }
421         |
422         '[' ']' array_len           { push(@{$_[3]}, "*"); $_[3] }
423         |
424         '[' anytext ']' array_len   { push(@{$_[4]}, "$_[2]"); $_[4] }
425 ;
426
427 property_list:
428         #empty
429         |
430         property_list '[' properties ']' { FlattenHash([$_[1],$_[3]]); }
431 ;
432
433 properties:
434         property                { $_[1] }
435         |
436         properties ',' property { FlattenHash([$_[1], $_[3]]); }
437 ;
438
439 property:
440         identifier                       {{ "$_[1]" => "1"     }}
441         |
442         identifier '(' commalisttext ')' {{ "$_[1]" => "$_[3]" }}
443 ;
444
445 commalisttext:
446         anytext
447         |
448         commalisttext ',' anytext { "$_[1],$_[3]" }
449 ;
450
451 anytext:
452         #empty
453         { "" }
454         |
455         identifier
456         |
457         constant
458         |
459         text
460         |
461         anytext '-' anytext  { "$_[1]$_[2]$_[3]" }
462         |
463         anytext '.' anytext  { "$_[1]$_[2]$_[3]" }
464         |
465         anytext '*' anytext  { "$_[1]$_[2]$_[3]" }
466         |
467         anytext '>' anytext  { "$_[1]$_[2]$_[3]" }
468         |
469         anytext '<' anytext  { "$_[1]$_[2]$_[3]" }
470         |
471         anytext '|' anytext  { "$_[1]$_[2]$_[3]" }
472         |
473         anytext '&' anytext  { "$_[1]$_[2]$_[3]" }
474         |
475         anytext '/' anytext  { "$_[1]$_[2]$_[3]" }
476         |
477         anytext '?' anytext  { "$_[1]$_[2]$_[3]" }
478         |
479         anytext ':' anytext  { "$_[1]$_[2]$_[3]" }
480         |
481         anytext '=' anytext  { "$_[1]$_[2]$_[3]" }
482         |
483         anytext '+' anytext  { "$_[1]$_[2]$_[3]" }
484         |
485         anytext '~' anytext  { "$_[1]$_[2]$_[3]" }
486         |
487         anytext '(' commalisttext ')' anytext  { "$_[1]$_[2]$_[3]$_[4]$_[5]" }
488         |
489         anytext '{' commalisttext '}' anytext  { "$_[1]$_[2]$_[3]$_[4]$_[5]" }
490 ;
491
492 identifier:
493         IDENTIFIER
494 ;
495
496 optional_identifier:
497         #empty { undef }
498         |
499         IDENTIFIER
500 ;
501
502 constant:
503         CONSTANT
504 ;
505
506 text:
507         TEXT { "\"$_[1]\"" }
508 ;
509
510 optional_semicolon:
511         #empty
512         |
513         ';'
514 ;
515
516
517 #####################################
518 # start code
519 %%
520
521 use Parse::Pidl qw(error);
522
523 #####################################################################
524 # flatten an array of hashes into a single hash
525 sub FlattenHash($)
526 {
527         my $a = shift;
528         my %b;
529         for my $d (@{$a}) {
530                 for my $k (keys %{$d}) {
531                 $b{$k} = $d->{$k};
532                 }
533         }
534         return \%b;
535 }
536
537 #####################################################################
538 # traverse a perl data structure removing any empty arrays or
539 # hashes and any hash elements that map to undef
540 sub CleanData($)
541 {
542         sub CleanData($);
543         my($v) = shift;
544
545         return undef if (not defined($v));
546
547         if (ref($v) eq "ARRAY") {
548                 foreach my $i (0 .. $#{$v}) {
549                         CleanData($v->[$i]);
550                 }
551                 # this removes any undefined elements from the array
552                 @{$v} = grep { defined $_ } @{$v};
553         } elsif (ref($v) eq "HASH") {
554                 foreach my $x (keys %{$v}) {
555                         CleanData($v->{$x});
556                         if (!defined $v->{$x}) {
557                                 delete($v->{$x});
558                                 next;
559                         }
560                 }
561         }
562
563         return $v;
564 }
565
566 sub _Error {
567         if (exists $_[0]->YYData->{ERRMSG}) {
568                 error($_[0]->YYData, $_[0]->YYData->{ERRMSG});
569                 delete $_[0]->YYData->{ERRMSG};
570                 return;
571         }
572
573         my $last_token = $_[0]->YYData->{LAST_TOKEN};
574
575         error($_[0]->YYData, "Syntax error near '$last_token'");
576 }
577
578 sub _Lexer($)
579 {
580         my($parser)=shift;
581
582         $parser->YYData->{INPUT} or return('',undef);
583
584 again:
585         $parser->YYData->{INPUT} =~ s/^[ \t]*//;
586
587         for ($parser->YYData->{INPUT}) {
588                 if (/^\#/) {
589                         if (s/^\# (\d+) \"(.*?)\"( \d+|)//) {
590                                 $parser->YYData->{LINE} = $1-1;
591                                 $parser->YYData->{FILE} = $2;
592                                 goto again;
593                         }
594                         if (s/^\#line (\d+) \"(.*?)\"( \d+|)//) {
595                                 $parser->YYData->{LINE} = $1-1;
596                                 $parser->YYData->{FILE} = $2;
597                                 goto again;
598                         }
599                         if (s/^(\#.*)$//m) {
600                                 goto again;
601                         }
602                 }
603                 if (s/^(\n)//) {
604                         $parser->YYData->{LINE}++;
605                         goto again;
606                 }
607                 if (s/^\"(.*?)\"//) {
608                         $parser->YYData->{LAST_TOKEN} = $1;
609                         return('TEXT',$1);
610                 }
611                 if (s/^(\d+)(\W|$)/$2/) {
612                         $parser->YYData->{LAST_TOKEN} = $1;
613                         return('CONSTANT',$1);
614                 }
615                 if (s/^([\w_]+)//) {
616                         $parser->YYData->{LAST_TOKEN} = $1;
617                         if ($1 =~
618                             /^(coclass|interface|import|importlib
619                               |include|cpp_quote|typedef
620                               |union|struct|enum|bitmap|pipe
621                               |void|const|unsigned|signed)$/x) {
622                                 return $1;
623                         }
624                         return('IDENTIFIER',$1);
625                 }
626                 if (s/^(.)//s) {
627                         $parser->YYData->{LAST_TOKEN} = $1;
628                         return($1,$1);
629                 }
630         }
631 }
632
633 sub parse_string
634 {
635         my ($data,$filename) = @_;
636
637         my $self = new Parse::Pidl::IDL;
638
639         $self->YYData->{FILE} = $filename;
640         $self->YYData->{INPUT} = $data;
641         $self->YYData->{LINE} = 0;
642         $self->YYData->{LAST_TOKEN} = "NONE";
643
644         my $idl = $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error );
645
646         return CleanData($idl);
647 }
648
649 sub parse_file($$)
650 {
651         my ($filename,$incdirs) = @_;
652
653         my $saved_delim = $/;
654         undef $/;
655         my $cpp = $ENV{CPP};
656         if (! defined $cpp) {
657                 $cpp = "cpp";
658         }
659         my $includes = join('',map { " -I$_" } @$incdirs);
660         my $data = `$cpp -D__PIDL__$includes -xc $filename`;
661         $/ = $saved_delim;
662
663         return parse_string($data, $filename);
664 }