r15260: Don't dereference NULL pointers to obtain array lengths - found by
[samba.git] / source / pidl / smb_interfaces.pm
1 ####################################################################
2 #
3 #    This file was generated using Parse::Yapp version 1.05.
4 #
5 #        Don't edit this file, use source file instead.
6 #
7 #             ANY CHANGE MADE HERE WILL BE LOST !
8 #
9 ####################################################################
10 package smb_interfaces;
11 use vars qw ( @ISA );
12 use strict;
13
14 @ISA= qw ( Parse::Yapp::Driver );
15 #Included Parse/Yapp/Driver.pm file----------------------------------------
16 {
17 #
18 # Module Parse::Yapp::Driver
19 #
20 # This module is part of the Parse::Yapp package available on your
21 # nearest CPAN
22 #
23 # Any use of this module in a standalone parser make the included
24 # text under the same copyright as the Parse::Yapp module itself.
25 #
26 # This notice should remain unchanged.
27 #
28 # (c) Copyright 1998-2001 Francois Desarmenien, all rights reserved.
29 # (see the pod text in Parse::Yapp module for use and distribution rights)
30 #
31
32 package Parse::Yapp::Driver;
33
34 require 5.004;
35
36 use strict;
37
38 use vars qw ( $VERSION $COMPATIBLE $FILENAME );
39
40 $VERSION = '1.05';
41 $COMPATIBLE = '0.07';
42 $FILENAME=__FILE__;
43
44 use Carp;
45
46 #Known parameters, all starting with YY (leading YY will be discarded)
47 my(%params)=(YYLEX => 'CODE', 'YYERROR' => 'CODE', YYVERSION => '',
48                          YYRULES => 'ARRAY', YYSTATES => 'ARRAY', YYDEBUG => '');
49 #Mandatory parameters
50 my(@params)=('LEX','RULES','STATES');
51
52 sub new {
53     my($class)=shift;
54         my($errst,$nberr,$token,$value,$check,$dotpos);
55     my($self)={ ERROR => \&_Error,
56                                 ERRST => \$errst,
57                 NBERR => \$nberr,
58                                 TOKEN => \$token,
59                                 VALUE => \$value,
60                                 DOTPOS => \$dotpos,
61                                 STACK => [],
62                                 DEBUG => 0,
63                                 CHECK => \$check };
64
65         _CheckParams( [], \%params, \@_, $self );
66
67                 exists($$self{VERSION})
68         and     $$self{VERSION} < $COMPATIBLE
69         and     croak "Yapp driver version $VERSION ".
70                           "incompatible with version $$self{VERSION}:\n".
71                           "Please recompile parser module.";
72
73         ref($class)
74     and $class=ref($class);
75
76     bless($self,$class);
77 }
78
79 sub YYParse {
80     my($self)=shift;
81     my($retval);
82
83         _CheckParams( \@params, \%params, \@_, $self );
84
85         if($$self{DEBUG}) {
86                 _DBLoad();
87                 $retval = eval '$self->_DBParse()';#Do not create stab entry on compile
88         $@ and die $@;
89         }
90         else {
91                 $retval = $self->_Parse();
92         }
93     $retval
94 }
95
96 sub YYData {
97         my($self)=shift;
98
99                 exists($$self{USER})
100         or      $$self{USER}={};
101
102         $$self{USER};
103         
104 }
105
106 sub YYErrok {
107         my($self)=shift;
108
109         ${$$self{ERRST}}=0;
110     undef;
111 }
112
113 sub YYNberr {
114         my($self)=shift;
115
116         ${$$self{NBERR}};
117 }
118
119 sub YYRecovering {
120         my($self)=shift;
121
122         ${$$self{ERRST}} != 0;
123 }
124
125 sub YYAbort {
126         my($self)=shift;
127
128         ${$$self{CHECK}}='ABORT';
129     undef;
130 }
131
132 sub YYAccept {
133         my($self)=shift;
134
135         ${$$self{CHECK}}='ACCEPT';
136     undef;
137 }
138
139 sub YYError {
140         my($self)=shift;
141
142         ${$$self{CHECK}}='ERROR';
143     undef;
144 }
145
146 sub YYSemval {
147         my($self)=shift;
148         my($index)= $_[0] - ${$$self{DOTPOS}} - 1;
149
150                 $index < 0
151         and     -$index <= @{$$self{STACK}}
152         and     return $$self{STACK}[$index][1];
153
154         undef;  #Invalid index
155 }
156
157 sub YYCurtok {
158         my($self)=shift;
159
160         @_
161     and ${$$self{TOKEN}}=$_[0];
162     ${$$self{TOKEN}};
163 }
164
165 sub YYCurval {
166         my($self)=shift;
167
168         @_
169     and ${$$self{VALUE}}=$_[0];
170     ${$$self{VALUE}};
171 }
172
173 sub YYExpect {
174     my($self)=shift;
175
176     keys %{$self->{STATES}[$self->{STACK}[-1][0]]{ACTIONS}}
177 }
178
179 sub YYLexer {
180     my($self)=shift;
181
182         $$self{LEX};
183 }
184
185
186 #################
187 # Private stuff #
188 #################
189
190
191 sub _CheckParams {
192         my($mandatory,$checklist,$inarray,$outhash)=@_;
193         my($prm,$value);
194         my($prmlst)={};
195
196         while(($prm,$value)=splice(@$inarray,0,2)) {
197         $prm=uc($prm);
198                         exists($$checklist{$prm})
199                 or      croak("Unknow parameter '$prm'");
200                         ref($value) eq $$checklist{$prm}
201                 or      croak("Invalid value for parameter '$prm'");
202         $prm=unpack('@2A*',$prm);
203                 $$outhash{$prm}=$value;
204         }
205         for (@$mandatory) {
206                         exists($$outhash{$_})
207                 or      croak("Missing mandatory parameter '".lc($_)."'");
208         }
209 }
210
211 sub _Error {
212         print "Parse error.\n";
213 }
214
215 sub _DBLoad {
216         {
217                 no strict 'refs';
218
219                         exists(${__PACKAGE__.'::'}{_DBParse})#Already loaded ?
220                 and     return;
221         }
222         my($fname)=__FILE__;
223         my(@drv);
224         open(DRV,"<$fname") or die "Report this as a BUG: Cannot open $fname";
225         while(<DRV>) {
226                         /^\s*sub\s+_Parse\s*{\s*$/ .. /^\s*}\s*#\s*_Parse\s*$/
227                 and     do {
228                         s/^#DBG>//;
229                         push(@drv,$_);
230                 }
231         }
232         close(DRV);
233
234         $drv[0]=~s/_P/_DBP/;
235         eval join('',@drv);
236 }
237
238 #Note that for loading debugging version of the driver,
239 #this file will be parsed from 'sub _Parse' up to '}#_Parse' inclusive.
240 #So, DO NOT remove comment at end of sub !!!
241 sub _Parse {
242     my($self)=shift;
243
244         my($rules,$states,$lex,$error)
245      = @$self{ 'RULES', 'STATES', 'LEX', 'ERROR' };
246         my($errstatus,$nberror,$token,$value,$stack,$check,$dotpos)
247      = @$self{ 'ERRST', 'NBERR', 'TOKEN', 'VALUE', 'STACK', 'CHECK', 'DOTPOS' };
248
249 #DBG>   my($debug)=$$self{DEBUG};
250 #DBG>   my($dbgerror)=0;
251
252 #DBG>   my($ShowCurToken) = sub {
253 #DBG>           my($tok)='>';
254 #DBG>           for (split('',$$token)) {
255 #DBG>                   $tok.=          (ord($_) < 32 or ord($_) > 126)
256 #DBG>                                   ?       sprintf('<%02X>',ord($_))
257 #DBG>                                   :       $_;
258 #DBG>           }
259 #DBG>           $tok.='<';
260 #DBG>   };
261
262         $$errstatus=0;
263         $$nberror=0;
264         ($$token,$$value)=(undef,undef);
265         @$stack=( [ 0, undef ] );
266         $$check='';
267
268     while(1) {
269         my($actions,$act,$stateno);
270
271         $stateno=$$stack[-1][0];
272         $actions=$$states[$stateno];
273
274 #DBG>   print STDERR ('-' x 40),"\n";
275 #DBG>           $debug & 0x2
276 #DBG>   and     print STDERR "In state $stateno:\n";
277 #DBG>           $debug & 0x08
278 #DBG>   and     print STDERR "Stack:[".
279 #DBG>                                    join(',',map { $$_[0] } @$stack).
280 #DBG>                                    "]\n";
281
282
283         if  (exists($$actions{ACTIONS})) {
284
285                                 defined($$token)
286             or  do {
287                                 ($$token,$$value)=&$lex($self);
288 #DBG>                           $debug & 0x01
289 #DBG>                   and     print STDERR "Need token. Got ".&$ShowCurToken."\n";
290                         };
291
292             $act=   exists($$actions{ACTIONS}{$$token})
293                     ?   $$actions{ACTIONS}{$$token}
294                     :   exists($$actions{DEFAULT})
295                         ?   $$actions{DEFAULT}
296                         :   undef;
297         }
298         else {
299             $act=$$actions{DEFAULT};
300 #DBG>                   $debug & 0x01
301 #DBG>           and     print STDERR "Don't need token.\n";
302         }
303
304             defined($act)
305         and do {
306
307                 $act > 0
308             and do {        #shift
309
310 #DBG>                           $debug & 0x04
311 #DBG>                   and     print STDERR "Shift and go to state $act.\n";
312
313                                         $$errstatus
314                                 and     do {
315                                         --$$errstatus;
316
317 #DBG>                                   $debug & 0x10
318 #DBG>                           and     $dbgerror
319 #DBG>                           and     $$errstatus == 0
320 #DBG>                           and     do {
321 #DBG>                                   print STDERR "**End of Error recovery.\n";
322 #DBG>                                   $dbgerror=0;
323 #DBG>                           };
324                                 };
325
326
327                 push(@$stack,[ $act, $$value ]);
328
329                                         $$token ne ''   #Don't eat the eof
330                                 and     $$token=$$value=undef;
331                 next;
332             };
333
334             #reduce
335             my($lhs,$len,$code,@sempar,$semval);
336             ($lhs,$len,$code)=@{$$rules[-$act]};
337
338 #DBG>                   $debug & 0x04
339 #DBG>           and     $act
340 #DBG>           and     print STDERR "Reduce using rule ".-$act." ($lhs,$len): ";
341
342                 $act
343             or  $self->YYAccept();
344
345             $$dotpos=$len;
346
347                 unpack('A1',$lhs) eq '@'    #In line rule
348             and do {
349                     $lhs =~ /^\@[0-9]+\-([0-9]+)$/
350                 or  die "In line rule name '$lhs' ill formed: ".
351                         "report it as a BUG.\n";
352                 $$dotpos = $1;
353             };
354
355             @sempar =       $$dotpos
356                         ?   map { $$_[1] } @$stack[ -$$dotpos .. -1 ]
357                         :   ();
358
359             $semval = $code ? &$code( $self, @sempar )
360                             : @sempar ? $sempar[0] : undef;
361
362             splice(@$stack,-$len,$len);
363
364                 $$check eq 'ACCEPT'
365             and do {
366
367 #DBG>                   $debug & 0x04
368 #DBG>           and     print STDERR "Accept.\n";
369
370                                 return($semval);
371                         };
372
373                 $$check eq 'ABORT'
374             and do {
375
376 #DBG>                   $debug & 0x04
377 #DBG>           and     print STDERR "Abort.\n";
378
379                                 return(undef);
380
381                         };
382
383 #DBG>                   $debug & 0x04
384 #DBG>           and     print STDERR "Back to state $$stack[-1][0], then ";
385
386                 $$check eq 'ERROR'
387             or  do {
388 #DBG>                           $debug & 0x04
389 #DBG>                   and     print STDERR 
390 #DBG>                               "go to state $$states[$$stack[-1][0]]{GOTOS}{$lhs}.\n";
391
392 #DBG>                           $debug & 0x10
393 #DBG>                   and     $dbgerror
394 #DBG>                   and     $$errstatus == 0
395 #DBG>                   and     do {
396 #DBG>                           print STDERR "**End of Error recovery.\n";
397 #DBG>                           $dbgerror=0;
398 #DBG>                   };
399
400                             push(@$stack,
401                      [ $$states[$$stack[-1][0]]{GOTOS}{$lhs}, $semval ]);
402                 $$check='';
403                 next;
404             };
405
406 #DBG>                   $debug & 0x04
407 #DBG>           and     print STDERR "Forced Error recovery.\n";
408
409             $$check='';
410
411         };
412
413         #Error
414             $$errstatus
415         or   do {
416
417             $$errstatus = 1;
418             &$error($self);
419                 $$errstatus # if 0, then YYErrok has been called
420             or  next;       # so continue parsing
421
422 #DBG>                   $debug & 0x10
423 #DBG>           and     do {
424 #DBG>                   print STDERR "**Entering Error recovery.\n";
425 #DBG>                   ++$dbgerror;
426 #DBG>           };
427
428             ++$$nberror;
429
430         };
431
432                         $$errstatus == 3        #The next token is not valid: discard it
433                 and     do {
434                                 $$token eq ''   # End of input: no hope
435                         and     do {
436 #DBG>                           $debug & 0x10
437 #DBG>                   and     print STDERR "**At eof: aborting.\n";
438                                 return(undef);
439                         };
440
441 #DBG>                   $debug & 0x10
442 #DBG>           and     print STDERR "**Dicard invalid token ".&$ShowCurToken.".\n";
443
444                         $$token=$$value=undef;
445                 };
446
447         $$errstatus=3;
448
449                 while(    @$stack
450                           and (         not exists($$states[$$stack[-1][0]]{ACTIONS})
451                                 or  not exists($$states[$$stack[-1][0]]{ACTIONS}{error})
452                                         or      $$states[$$stack[-1][0]]{ACTIONS}{error} <= 0)) {
453
454 #DBG>                   $debug & 0x10
455 #DBG>           and     print STDERR "**Pop state $$stack[-1][0].\n";
456
457                         pop(@$stack);
458                 }
459
460                         @$stack
461                 or      do {
462
463 #DBG>                   $debug & 0x10
464 #DBG>           and     print STDERR "**No state left on stack: aborting.\n";
465
466                         return(undef);
467                 };
468
469                 #shift the error token
470
471 #DBG>                   $debug & 0x10
472 #DBG>           and     print STDERR "**Shift \$error token and go to state ".
473 #DBG>                                            $$states[$$stack[-1][0]]{ACTIONS}{error}.
474 #DBG>                                            ".\n";
475
476                 push(@$stack, [ $$states[$$stack[-1][0]]{ACTIONS}{error}, undef ]);
477
478     }
479
480     #never reached
481         croak("Error in driver logic. Please, report it as a BUG");
482
483 }#_Parse
484 #DO NOT remove comment
485
486 1;
487
488 }
489 #End of include--------------------------------------------------
490
491
492
493
494 sub new {
495         my($class)=shift;
496         ref($class)
497     and $class=ref($class);
498
499     my($self)=$class->SUPER::new( yyversion => '1.05',
500                                   yystates =>
501 [
502         {#State 0
503                 ACTIONS => {
504                         'UNION' => 5,
505                         'ENUM' => 1,
506                         'TYPEDEF' => 7,
507                         'STRUCT' => 2
508                 },
509                 GOTOS => {
510                         'struct' => 6,
511                         'enum' => 9,
512                         'typedef' => 8,
513                         'union' => 10,
514                         'definitions' => 3,
515                         'definition' => 4
516                 }
517         },
518         {#State 1
519                 ACTIONS => {
520                         'IDENTIFIER' => 11
521                 }
522         },
523         {#State 2
524                 ACTIONS => {
525                         'IDENTIFIER' => 12
526                 },
527                 DEFAULT => -33,
528                 GOTOS => {
529                         'optional_identifier' => 13
530                 }
531         },
532         {#State 3
533                 ACTIONS => {
534                         '' => 14,
535                         'UNION' => 5,
536                         'ENUM' => 1,
537                         'TYPEDEF' => 7,
538                         'STRUCT' => 2
539                 },
540                 GOTOS => {
541                         'struct' => 6,
542                         'typedef' => 8,
543                         'enum' => 9,
544                         'union' => 10,
545                         'definition' => 15
546                 }
547         },
548         {#State 4
549                 DEFAULT => -1
550         },
551         {#State 5
552                 ACTIONS => {
553                         'IDENTIFIER' => 12
554                 },
555                 DEFAULT => -33,
556                 GOTOS => {
557                         'optional_identifier' => 16
558                 }
559         },
560         {#State 6
561                 DEFAULT => -3
562         },
563         {#State 7
564                 ACTIONS => {
565                         'STRUCT' => 17
566                 }
567         },
568         {#State 8
569                 DEFAULT => -5
570         },
571         {#State 9
572                 DEFAULT => -6
573         },
574         {#State 10
575                 DEFAULT => -4
576         },
577         {#State 11
578                 ACTIONS => {
579                         "{" => 18
580                 }
581         },
582         {#State 12
583                 DEFAULT => -32
584         },
585         {#State 13
586                 ACTIONS => {
587                         "{" => 19
588                 }
589         },
590         {#State 14
591                 DEFAULT => 0
592         },
593         {#State 15
594                 DEFAULT => -2
595         },
596         {#State 16
597                 ACTIONS => {
598                         "{" => 20
599                 }
600         },
601         {#State 17
602                 ACTIONS => {
603                         "{" => 21
604                 }
605         },
606         {#State 18
607                 ACTIONS => {
608                         'IDENTIFIER' => 22
609                 },
610                 GOTOS => {
611                         'enum_identifiers' => 23,
612                         'enum_identifier' => 24
613                 }
614         },
615         {#State 19
616                 DEFAULT => -15,
617                 GOTOS => {
618                         'elements' => 25
619                 }
620         },
621         {#State 20
622                 DEFAULT => -15,
623                 GOTOS => {
624                         'elements' => 26
625                 }
626         },
627         {#State 21
628                 DEFAULT => -15,
629                 GOTOS => {
630                         'elements' => 27
631                 }
632         },
633         {#State 22
634                 ACTIONS => {
635                         "=" => 28
636                 },
637                 DEFAULT => -13
638         },
639         {#State 23
640                 ACTIONS => {
641                         "}" => 29,
642                         "," => 30
643                 }
644         },
645         {#State 24
646                 DEFAULT => -11
647         },
648         {#State 25
649                 ACTIONS => {
650                         "}" => 31,
651                         'UNION' => 37,
652                         'IDENTIFIER' => 33,
653                         'ENUM' => 32,
654                         'STRUCT' => 35,
655                         'CONST' => 34
656                 },
657                 GOTOS => {
658                         'struct' => 38,
659                         'type' => 39,
660                         'union' => 40,
661                         'element' => 36
662                 }
663         },
664         {#State 26
665                 ACTIONS => {
666                         "}" => 41,
667                         'UNION' => 37,
668                         'IDENTIFIER' => 33,
669                         'ENUM' => 32,
670                         'STRUCT' => 35,
671                         'CONST' => 34
672                 },
673                 GOTOS => {
674                         'struct' => 38,
675                         'type' => 39,
676                         'union' => 40,
677                         'element' => 36
678                 }
679         },
680         {#State 27
681                 ACTIONS => {
682                         "}" => 42,
683                         'UNION' => 37,
684                         'IDENTIFIER' => 33,
685                         'ENUM' => 32,
686                         'STRUCT' => 35,
687                         'CONST' => 34
688                 },
689                 GOTOS => {
690                         'struct' => 38,
691                         'type' => 39,
692                         'union' => 40,
693                         'element' => 36
694                 }
695         },
696         {#State 28
697                 ACTIONS => {
698                         'IDENTIFIER' => 43
699                 }
700         },
701         {#State 29
702                 ACTIONS => {
703                         ";" => 44
704                 }
705         },
706         {#State 30
707                 ACTIONS => {
708                         'IDENTIFIER' => 22
709                 },
710                 GOTOS => {
711                         'enum_identifier' => 45
712                 }
713         },
714         {#State 31
715                 DEFAULT => -28,
716                 GOTOS => {
717                         'pointers' => 46
718                 }
719         },
720         {#State 32
721                 ACTIONS => {
722                         'IDENTIFIER' => 47
723                 }
724         },
725         {#State 33
726                 DEFAULT => -26
727         },
728         {#State 34
729                 ACTIONS => {
730                         'IDENTIFIER' => 33,
731                         'ENUM' => 32
732                 },
733                 GOTOS => {
734                         'type' => 48
735                 }
736         },
737         {#State 35
738                 ACTIONS => {
739                         'IDENTIFIER' => 49
740                 },
741                 DEFAULT => -33,
742                 GOTOS => {
743                         'optional_identifier' => 13
744                 }
745         },
746         {#State 36
747                 DEFAULT => -16
748         },
749         {#State 37
750                 ACTIONS => {
751                         'IDENTIFIER' => 50
752                 },
753                 DEFAULT => -33,
754                 GOTOS => {
755                         'optional_identifier' => 16
756                 }
757         },
758         {#State 38
759                 DEFAULT => -18
760         },
761         {#State 39
762                 DEFAULT => -28,
763                 GOTOS => {
764                         'pointers' => 51
765                 }
766         },
767         {#State 40
768                 DEFAULT => -19
769         },
770         {#State 41
771                 DEFAULT => -28,
772                 GOTOS => {
773                         'pointers' => 52
774                 }
775         },
776         {#State 42
777                 ACTIONS => {
778                         'IDENTIFIER' => 12
779                 },
780                 DEFAULT => -33,
781                 GOTOS => {
782                         'optional_identifier' => 53
783                 }
784         },
785         {#State 43
786                 DEFAULT => -14
787         },
788         {#State 44
789                 DEFAULT => -10
790         },
791         {#State 45
792                 DEFAULT => -12
793         },
794         {#State 46
795                 ACTIONS => {
796                         'IDENTIFIER' => 12,
797                         "*" => 55
798                 },
799                 DEFAULT => -33,
800                 GOTOS => {
801                         'optional_identifier' => 54,
802                         'optional_identifiers' => 56
803                 }
804         },
805         {#State 47
806                 DEFAULT => -27
807         },
808         {#State 48
809                 DEFAULT => -28,
810                 GOTOS => {
811                         'pointers' => 57
812                 }
813         },
814         {#State 49
815                 ACTIONS => {
816                         "{" => -32
817                 },
818                 DEFAULT => -28,
819                 GOTOS => {
820                         'pointers' => 58
821                 }
822         },
823         {#State 50
824                 ACTIONS => {
825                         "{" => -32
826                 },
827                 DEFAULT => -28,
828                 GOTOS => {
829                         'pointers' => 59
830                 }
831         },
832         {#State 51
833                 ACTIONS => {
834                         'IDENTIFIER' => 60,
835                         "*" => 55
836                 }
837         },
838         {#State 52
839                 ACTIONS => {
840                         'IDENTIFIER' => 12,
841                         "*" => 55
842                 },
843                 DEFAULT => -33,
844                 GOTOS => {
845                         'optional_identifier' => 61
846                 }
847         },
848         {#State 53
849                 ACTIONS => {
850                         ";" => 62
851                 }
852         },
853         {#State 54
854                 DEFAULT => -30
855         },
856         {#State 55
857                 DEFAULT => -29
858         },
859         {#State 56
860                 ACTIONS => {
861                         ";" => 63,
862                         "," => 64
863                 }
864         },
865         {#State 57
866                 ACTIONS => {
867                         'IDENTIFIER' => 65,
868                         "*" => 55
869                 }
870         },
871         {#State 58
872                 ACTIONS => {
873                         'IDENTIFIER' => 66,
874                         "*" => 55
875                 }
876         },
877         {#State 59
878                 ACTIONS => {
879                         'IDENTIFIER' => 67,
880                         "*" => 55
881                 }
882         },
883         {#State 60
884                 ACTIONS => {
885                         "[" => 69
886                 },
887                 DEFAULT => -24,
888                 GOTOS => {
889                         'array' => 68
890                 }
891         },
892         {#State 61
893                 ACTIONS => {
894                         ";" => 70
895                 }
896         },
897         {#State 62
898                 DEFAULT => -9
899         },
900         {#State 63
901                 DEFAULT => -7
902         },
903         {#State 64
904                 ACTIONS => {
905                         'IDENTIFIER' => 12
906                 },
907                 DEFAULT => -33,
908                 GOTOS => {
909                         'optional_identifier' => 71
910                 }
911         },
912         {#State 65
913                 ACTIONS => {
914                         "[" => 69
915                 },
916                 DEFAULT => -24,
917                 GOTOS => {
918                         'array' => 72
919                 }
920         },
921         {#State 66
922                 ACTIONS => {
923                         ";" => 73
924                 }
925         },
926         {#State 67
927                 ACTIONS => {
928                         ";" => 74
929                 }
930         },
931         {#State 68
932                 ACTIONS => {
933                         ";" => 75
934                 }
935         },
936         {#State 69
937                 ACTIONS => {
938                         'CONSTANT' => 76
939                 }
940         },
941         {#State 70
942                 DEFAULT => -8
943         },
944         {#State 71
945                 DEFAULT => -31
946         },
947         {#State 72
948                 ACTIONS => {
949                         ";" => 77
950                 }
951         },
952         {#State 73
953                 DEFAULT => -20
954         },
955         {#State 74
956                 DEFAULT => -21
957         },
958         {#State 75
959                 DEFAULT => -23
960         },
961         {#State 76
962                 ACTIONS => {
963                         "]" => 78
964                 }
965         },
966         {#State 77
967                 DEFAULT => -22
968         },
969         {#State 78
970                 DEFAULT => -25
971         }
972 ],
973                                   yyrules  =>
974 [
975         [#Rule 0
976                  '$start', 2, undef
977         ],
978         [#Rule 1
979                  'definitions', 1,
980 sub
981 #line 14 "build/pidl/smb_interfaces.yp"
982 { [$_[1]] }
983         ],
984         [#Rule 2
985                  'definitions', 2,
986 sub
987 #line 15 "build/pidl/smb_interfaces.yp"
988 { push(@{$_[1]}, $_[2]); $_[1] }
989         ],
990         [#Rule 3
991                  'definition', 1, undef
992         ],
993         [#Rule 4
994                  'definition', 1, undef
995         ],
996         [#Rule 5
997                  'definition', 1, undef
998         ],
999         [#Rule 6
1000                  'definition', 1, undef
1001         ],
1002         [#Rule 7
1003                  'struct', 8,
1004 sub
1005 #line 26 "build/pidl/smb_interfaces.yp"
1006 {
1007                 {
1008                         "NAME" => $_[7],
1009                         "STRUCT_NAME" => $_[2],
1010                         "TYPE" => "struct",
1011                         "DATA" => $_[4],
1012                 }
1013         }
1014         ],
1015         [#Rule 8
1016                  'union', 8,
1017 sub
1018 #line 38 "build/pidl/smb_interfaces.yp"
1019 {
1020                 {
1021                         "NAME" => $_[7],
1022                         "UNION_NAME" => $_[2],
1023                         "TYPE" => "union",
1024                         "DATA" => $_[4],
1025                 }
1026         }
1027         ],
1028         [#Rule 9
1029                  'typedef', 7, undef
1030         ],
1031         [#Rule 10
1032                  'enum', 6, undef
1033         ],
1034         [#Rule 11
1035                  'enum_identifiers', 1, undef
1036         ],
1037         [#Rule 12
1038                  'enum_identifiers', 3, undef
1039         ],
1040         [#Rule 13
1041                  'enum_identifier', 1, undef
1042         ],
1043         [#Rule 14
1044                  'enum_identifier', 3, undef
1045         ],
1046         [#Rule 15
1047                  'elements', 0, undef
1048         ],
1049         [#Rule 16
1050                  'elements', 2,
1051 sub
1052 #line 65 "build/pidl/smb_interfaces.yp"
1053 { push(@{$_[1]}, $_[2]); $_[1] }
1054         ],
1055         [#Rule 17
1056                  'element', 0, undef
1057         ],
1058         [#Rule 18
1059                  'element', 1, undef
1060         ],
1061         [#Rule 19
1062                  'element', 1, undef
1063         ],
1064         [#Rule 20
1065                  'element', 5,
1066 sub
1067 #line 72 "build/pidl/smb_interfaces.yp"
1068 {{
1069                         "NAME" => [$_[2]],
1070                         "POINTERS" => $_[3],
1071                         "TYPE" => "struct $_[2]",
1072                 }}
1073         ],
1074         [#Rule 21
1075                  'element', 5,
1076 sub
1077 #line 78 "build/pidl/smb_interfaces.yp"
1078 {{
1079                         "NAME" => $_[2],
1080                         "POINTERS" => $_[3],
1081                         "TYPE" => "union $_[2]",
1082                 }}
1083         ],
1084         [#Rule 22
1085                  'element', 6,
1086 sub
1087 #line 84 "build/pidl/smb_interfaces.yp"
1088 {{
1089                            "NAME" => [$_[4]],
1090                            "TYPE" => $_[2],
1091                            "POINTERS" => $_[3],
1092                 }}
1093         ],
1094         [#Rule 23
1095                  'element', 5,
1096 sub
1097 #line 90 "build/pidl/smb_interfaces.yp"
1098 {{
1099                            "NAME" => [$_[3]],
1100                            "TYPE" => $_[1],
1101                            "POINTERS" => $_[2],
1102                            "ARRAY_LENGTH" => $_[4]
1103                 }}
1104         ],
1105         [#Rule 24
1106                  'array', 0, undef
1107         ],
1108         [#Rule 25
1109                  'array', 3,
1110 sub
1111 #line 99 "build/pidl/smb_interfaces.yp"
1112 { int($_[2]) }
1113         ],
1114         [#Rule 26
1115                  'type', 1, undef
1116         ],
1117         [#Rule 27
1118                  'type', 2,
1119 sub
1120 #line 104 "build/pidl/smb_interfaces.yp"
1121 { "enum $_[2]" }
1122         ],
1123         [#Rule 28
1124                  'pointers', 0, undef
1125         ],
1126         [#Rule 29
1127                  'pointers', 2,
1128 sub
1129 #line 109 "build/pidl/smb_interfaces.yp"
1130 { $_[1]+1 }
1131         ],
1132         [#Rule 30
1133                  'optional_identifiers', 1,
1134 sub
1135 #line 112 "build/pidl/smb_interfaces.yp"
1136 { [$_[1]] }
1137         ],
1138         [#Rule 31
1139                  'optional_identifiers', 3,
1140 sub
1141 #line 113 "build/pidl/smb_interfaces.yp"
1142 { push(@{$_[1]}, $_[3]); $_[1] }
1143         ],
1144         [#Rule 32
1145                  'optional_identifier', 1, undef
1146         ],
1147         [#Rule 33
1148                  'optional_identifier', 0, undef
1149         ]
1150 ],
1151                                   @_);
1152     bless($self,$class);
1153 }
1154
1155 #line 119 "build/pidl/smb_interfaces.yp"
1156
1157
1158 #####################################################################
1159 # traverse a perl data structure removing any empty arrays or
1160 # hashes and any hash elements that map to undef
1161 sub CleanData($)
1162 {
1163     sub CleanData($);
1164     my($v) = shift;
1165     if (ref($v) eq "ARRAY") {
1166         foreach my $i (0 .. $#{$v}) {
1167             CleanData($v->[$i]);
1168             if (ref($v->[$i]) eq "ARRAY" && $#{$v->[$i]}==-1) { 
1169                     $v->[$i] = undef; 
1170                     next; 
1171             }
1172         }
1173         # this removes any undefined elements from the array
1174         @{$v} = grep { defined $_ } @{$v};
1175     } elsif (ref($v) eq "HASH") {
1176         foreach my $x (keys %{$v}) {
1177             CleanData($v->{$x});
1178             if (!defined $v->{$x}) { delete($v->{$x}); next; }
1179             if (ref($v->{$x}) eq "ARRAY" && $#{$v->{$x}}==-1) { delete($v->{$x}); next; }
1180         }
1181     }
1182         return $v;
1183 }
1184
1185 sub _Error {
1186     if (exists $_[0]->YYData->{ERRMSG}) {
1187                 print $_[0]->YYData->{ERRMSG};
1188                 delete $_[0]->YYData->{ERRMSG};
1189                 return;
1190         };
1191         my $line = $_[0]->YYData->{LINE};
1192         my $last_token = $_[0]->YYData->{LAST_TOKEN};
1193         my $file = $_[0]->YYData->{INPUT_FILENAME};
1194         
1195         print "$file:$line: Syntax error near '$last_token'\n";
1196 }
1197
1198 sub _Lexer($)
1199 {
1200         my($parser)=shift;
1201
1202     $parser->YYData->{INPUT} or return('',undef);
1203
1204 again:
1205         $parser->YYData->{INPUT} =~ s/^[ \t]*//;
1206
1207         for ($parser->YYData->{INPUT}) {
1208                 if (/^\#/) {
1209                         if (s/^\# (\d+) \"(.*?)\"( \d+|)//) {
1210                                 $parser->YYData->{LINE} = $1-1;
1211                                 $parser->YYData->{INPUT_FILENAME} = $2;
1212                                 goto again;
1213                         }
1214                         if (s/^\#line (\d+) \"(.*?)\"( \d+|)//) {
1215                                 $parser->YYData->{LINE} = $1-1;
1216                                 $parser->YYData->{INPUT_FILENAME} = $2;
1217                                 goto again;
1218                         }
1219                         if (s/^(\#.*)$//m) {
1220                                 goto again;
1221                         }
1222                 }
1223                 if (s/^(\n)//) {
1224                         $parser->YYData->{LINE}++;
1225                         goto again;
1226                 }
1227                 if (s/^\"(.*?)\"//) {
1228                         $parser->YYData->{LAST_TOKEN} = $1;
1229                         return('TEXT',$1); 
1230                 }
1231                 if (s/^(\d+)(\W|$)/$2/) {
1232                         $parser->YYData->{LAST_TOKEN} = $1;
1233                         return('CONSTANT',$1); 
1234                 }
1235                 if (s/^([\w_]+)//) {
1236                         $parser->YYData->{LAST_TOKEN} = $1;
1237                         if ($1 =~ 
1238                             /^(const|typedef|union|struct|enum)$/x) {
1239                                 return uc($1);
1240                         }
1241                         return('IDENTIFIER',$1);
1242                 }
1243                 if (s/^(.)//s) {
1244                         $parser->YYData->{LAST_TOKEN} = $1;
1245                         return($1,$1);
1246                 }
1247         }
1248 }
1249
1250 sub parse($$)
1251 {
1252         my ($self,$filename) = @_;
1253
1254         my $saved_delim = $/;
1255         undef $/;
1256         my $cpp = $ENV{CPP};
1257         if (! defined $cpp) {
1258                 $cpp = "cpp"
1259         }
1260         my $data = `$cpp -D__PIDL__ -xc $filename`;
1261         $/ = $saved_delim;
1262
1263     $self->YYData->{INPUT} = $data;
1264     $self->YYData->{LINE} = 0;
1265     $self->YYData->{LAST_TOKEN} = "NONE";
1266
1267         my $idl = $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error );
1268
1269         return CleanData($idl);
1270 }
1271
1272 1;