File Coverage

blib/lib/Test/Collectd/Config/Parse.pm
Criterion Covered Total %
statement 86 166 51.8
branch 30 72 41.6
condition 1 12 8.3
subroutine 11 24 45.8
pod 0 14 0.0
total 128 288 44.4


line stmt bran cond sub pod time code
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 Test::Collectd::Config::Parse;
11 6     6   21 use vars qw ( @ISA );
  6         10  
  6         290  
12 6     6   27 use strict;
  6         8  
  6         275  
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 6     6   19 use strict;
  6         33  
  6         141  
37              
38 6     6   21 use vars qw ( $VERSION $COMPATIBLE $FILENAME );
  6         7  
  6         301  
39              
40             $VERSION = '1.05';
41             $COMPATIBLE = '0.07';
42             $FILENAME=__FILE__;
43              
44 6     6   22 use Carp;
  6         5  
  6         4579  
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 7     7 0 13 my($class)=shift;
54 7         9 my($errst,$nberr,$token,$value,$check,$dotpos);
55 7         67 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 7         29 _CheckParams( [], \%params, \@_, $self );
66              
67 7 50 33     63 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 7 50       12 ref($class)
74             and $class=ref($class);
75              
76 7         25 bless($self,$class);
77             }
78              
79             sub YYParse {
80 7     7 0 10 my($self)=shift;
81 7         10 my($retval);
82              
83 7         17 _CheckParams( \@params, \%params, \@_, $self );
84              
85 7 50       23 if($$self{DEBUG}) {
86 0         0 _DBLoad();
87 0         0 $retval = eval '$self->_DBParse()';#Do not create stab entry on compile
88 0 0       0 $@ and die $@;
89             }
90             else {
91 7         30 $retval = $self->_Parse();
92             }
93 7         322 $retval
94             }
95              
96             sub YYData {
97 0     0 0 0 my($self)=shift;
98              
99 0 0       0 exists($$self{USER})
100             or $$self{USER}={};
101              
102 0         0 $$self{USER};
103            
104             }
105              
106             sub YYErrok {
107 0     0 0 0 my($self)=shift;
108              
109 0         0 ${$$self{ERRST}}=0;
  0         0  
110 0         0 undef;
111             }
112              
113             sub YYNberr {
114 0     0 0 0 my($self)=shift;
115              
116 0         0 ${$$self{NBERR}};
  0         0  
117             }
118              
119             sub YYRecovering {
120 0     0 0 0 my($self)=shift;
121              
122 0         0 ${$$self{ERRST}} != 0;
  0         0  
123             }
124              
125             sub YYAbort {
126 0     0 0 0 my($self)=shift;
127              
128 0         0 ${$$self{CHECK}}='ABORT';
  0         0  
129 0         0 undef;
130             }
131              
132             sub YYAccept {
133 7     7 0 13 my($self)=shift;
134              
135 7         17 ${$$self{CHECK}}='ACCEPT';
  7         17  
136 7         8 undef;
137             }
138              
139             sub YYError {
140 0     0 0 0 my($self)=shift;
141              
142 0         0 ${$$self{CHECK}}='ERROR';
  0         0  
143 0         0 undef;
144             }
145              
146             sub YYSemval {
147 0     0 0 0 my($self)=shift;
148 0         0 my($index)= $_[0] - ${$$self{DOTPOS}} - 1;
  0         0  
149              
150 0         0 $index < 0
151 0 0 0     0 and -$index <= @{$$self{STACK}}
152             and return $$self{STACK}[$index][1];
153              
154 0         0 undef; #Invalid index
155             }
156              
157             sub YYCurtok {
158 0     0 0 0 my($self)=shift;
159              
160             @_
161 0 0       0 and ${$$self{TOKEN}}=$_[0];
  0         0  
162 0         0 ${$$self{TOKEN}};
  0         0  
163             }
164              
165             sub YYCurval {
166 0     0 0 0 my($self)=shift;
167              
168             @_
169 0 0       0 and ${$$self{VALUE}}=$_[0];
  0         0  
170 0         0 ${$$self{VALUE}};
  0         0  
171             }
172              
173             sub YYExpect {
174 0     0 0 0 my($self)=shift;
175              
176 0         0 keys %{$self->{STATES}[$self->{STACK}[-1][0]]{ACTIONS}}
  0         0  
177             }
178              
179             sub YYLexer {
180 0     0 0 0 my($self)=shift;
181              
182 0         0 $$self{LEX};
183             }
184              
185              
186             #################
187             # Private stuff #
188             #################
189              
190              
191             sub _CheckParams {
192 14     14   18 my($mandatory,$checklist,$inarray,$outhash)=@_;
193 14         12 my($prm,$value);
194 14         14 my($prmlst)={};
195              
196 14         41 while(($prm,$value)=splice(@$inarray,0,2)) {
197 42         42 $prm=uc($prm);
198 42 50       62 exists($$checklist{$prm})
199             or croak("Unknow parameter '$prm'");
200 42 50       64 ref($value) eq $$checklist{$prm}
201             or croak("Invalid value for parameter '$prm'");
202 42         73 $prm=unpack('@2A*',$prm);
203 42         95 $$outhash{$prm}=$value;
204             }
205 14         30 for (@$mandatory) {
206 21 50       36 exists($$outhash{$_})
207             or croak("Missing mandatory parameter '".lc($_)."'");
208             }
209             }
210              
211             sub _Error {
212 0     0   0 print "Parse error.\n";
213             }
214              
215             sub _DBLoad {
216             {
217 6     6   25 no strict 'refs';
  6     0   6  
  6         7463  
  0         0  
218              
219 0 0       0 exists(${__PACKAGE__.'::'}{_DBParse})#Already loaded ?
  0         0  
220             and return;
221             }
222 0         0 my($fname)=__FILE__;
223 0         0 my(@drv);
224 0 0       0 open(DRV,"<$fname") or die "Report this as a BUG: Cannot open $fname";
225 0         0 while() {
226             /^\s*sub\s+_Parse\s*{\s*$/ .. /^\s*}\s*#\s*_Parse\s*$/
227 0 0       0 and do {
228 0         0 s/^#DBG>//;
229 0         0 push(@drv,$_);
230             }
231             }
232 0         0 close(DRV);
233              
234 0         0 $drv[0]=~s/_P/_DBP/;
235 0         0 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 7     7   9 my($self)=shift;
243              
244 7         19 my($rules,$states,$lex,$error)
245             = @$self{ 'RULES', 'STATES', 'LEX', 'ERROR' };
246 7         16 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 7         11 $$errstatus=0;
263 7         8 $$nberror=0;
264 7         8 ($$token,$$value)=(undef,undef);
265 7         12 @$stack=( [ 0, undef ] );
266 7         7 $$check='';
267              
268 7         6 while(1) {
269 676         390 my($actions,$act,$stateno);
270              
271 676         505 $stateno=$$stack[-1][0];
272 676         428 $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 676 100       733 if (exists($$actions{ACTIONS})) {
284              
285             defined($$token)
286 265 100       309 or do {
287 258         386 ($$token,$$value)=&$lex($self);
288             #DBG> $debug & 0x01
289             #DBG> and print STDERR "Need token. Got ".&$ShowCurToken."\n";
290             };
291              
292 265 50       1224 $act= exists($$actions{ACTIONS}{$$token})
    100          
293             ? $$actions{ACTIONS}{$$token}
294             : exists($$actions{DEFAULT})
295             ? $$actions{DEFAULT}
296             : undef;
297             }
298             else {
299 411         328 $act=$$actions{DEFAULT};
300             #DBG> $debug & 0x01
301             #DBG> and print STDERR "Don't need token.\n";
302             }
303              
304             defined($act)
305 676 50       775 and do {
306              
307             $act > 0
308 676 100       738 and do { #shift
309              
310             #DBG> $debug & 0x04
311             #DBG> and print STDERR "Shift and go to state $act.\n";
312              
313             $$errstatus
314 258 50       277 and do {
315 0         0 --$$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 258         320 push(@$stack,[ $act, $$value ]);
328              
329 258 100       367 $$token ne '' #Don't eat the eof
330             and $$token=$$value=undef;
331 258         192 next;
332             };
333              
334             #reduce
335 418         219 my($lhs,$len,$code,@sempar,$semval);
336 418         236 ($lhs,$len,$code)=@{$$rules[-$act]};
  418         500  
337              
338             #DBG> $debug & 0x04
339             #DBG> and $act
340             #DBG> and print STDERR "Reduce using rule ".-$act." ($lhs,$len): ";
341              
342 418 100       504 $act
343             or $self->YYAccept();
344              
345 418         232 $$dotpos=$len;
346              
347             unpack('A1',$lhs) eq '@' #In line rule
348 418 50       799 and do {
349 0 0       0 $lhs =~ /^\@[0-9]+\-([0-9]+)$/
350             or die "In line rule name '$lhs' ill formed: ".
351             "report it as a BUG.\n";
352 0         0 $$dotpos = $1;
353             };
354              
355 669         810 @sempar = $$dotpos
356 418 50       809 ? map { $$_[1] } @$stack[ -$$dotpos .. -1 ]
357             : ();
358              
359 418 50       784 $semval = $code ? &$code( $self, @sempar )
    100          
360             : @sempar ? $sempar[0] : undef;
361              
362 418         433 splice(@$stack,-$len,$len);
363              
364             $$check eq 'ACCEPT'
365 418 100       542 and do {
366              
367             #DBG> $debug & 0x04
368             #DBG> and print STDERR "Accept.\n";
369              
370 7         22 return($semval);
371             };
372              
373             $$check eq 'ABORT'
374 411 50       442 and do {
375              
376             #DBG> $debug & 0x04
377             #DBG> and print STDERR "Abort.\n";
378              
379 0         0 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 411 50       433 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 411         611 push(@$stack,
401             [ $$states[$$stack[-1][0]]{GOTOS}{$lhs}, $semval ]);
402 411         283 $$check='';
403 411         391 next;
404             };
405              
406             #DBG> $debug & 0x04
407             #DBG> and print STDERR "Forced Error recovery.\n";
408              
409 0           $$check='';
410              
411             };
412              
413             #Error
414             $$errstatus
415 0 0         or do {
416              
417 0           $$errstatus = 1;
418 0           &$error($self);
419 0 0         $$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 0           ++$$nberror;
429              
430             };
431              
432             $$errstatus == 3 #The next token is not valid: discard it
433 0 0         and do {
434             $$token eq '' # End of input: no hope
435 0 0         and do {
436             #DBG> $debug & 0x10
437             #DBG> and print STDERR "**At eof: aborting.\n";
438 0           return(undef);
439             };
440              
441             #DBG> $debug & 0x10
442             #DBG> and print STDERR "**Dicard invalid token ".&$ShowCurToken.".\n";
443              
444 0           $$token=$$value=undef;
445             };
446              
447 0           $$errstatus=3;
448              
449 0   0       while( @$stack
      0        
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 0           pop(@$stack);
458             }
459              
460             @$stack
461 0 0         or do {
462              
463             #DBG> $debug & 0x10
464             #DBG> and print STDERR "**No state left on stack: aborting.\n";
465              
466 0           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 0           push(@$stack, [ $$states[$$stack[-1][0]]{ACTIONS}{error}, undef ]);
477              
478             }
479              
480             #never reached
481 0           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             #line 19 "parser.yp"
493              
494             sub YYERROR {
495             join " ", @_;
496             }
497              
498              
499             sub new {
500             my($class)=shift;
501             ref($class)
502             and $class=ref($class);
503              
504             my($self)=$class->SUPER::new( yyversion => '1.05',
505             yystates =>
506             [
507             {#State 0
508             ACTIONS => {
509             'OPENBRAC' => 5,
510             'EOL' => 6,
511             'UNQUOTED_STRING' => 10
512             },
513             GOTOS => {
514             'statement' => 9,
515             'identifier' => 8,
516             'option' => 1,
517             'block' => 7,
518             'block_begin' => 2,
519             'entire_file' => 4,
520             'statement_list' => 3
521             }
522             },
523             {#State 1
524             DEFAULT => -15
525             },
526             {#State 2
527             ACTIONS => {
528             'UNQUOTED_STRING' => 10,
529             'EOL' => 6,
530             'OPENBRAC' => 5
531             },
532             GOTOS => {
533             'option' => 1,
534             'block_begin' => 2,
535             'block' => 7,
536             'identifier' => 8,
537             'statement' => 9,
538             'statement_list' => 11
539             }
540             },
541             {#State 3
542             ACTIONS => {
543             'EOL' => 6,
544             'OPENBRAC' => 5,
545             'UNQUOTED_STRING' => 10
546             },
547             DEFAULT => -20,
548             GOTOS => {
549             'block' => 7,
550             'block_begin' => 2,
551             'option' => 1,
552             'identifier' => 8,
553             'statement' => 12
554             }
555             },
556             {#State 4
557             ACTIONS => {
558             '' => 13
559             }
560             },
561             {#State 5
562             ACTIONS => {
563             'UNQUOTED_STRING' => 10
564             },
565             GOTOS => {
566             'identifier' => 14
567             }
568             },
569             {#State 6
570             DEFAULT => -17
571             },
572             {#State 7
573             DEFAULT => -16
574             },
575             {#State 8
576             ACTIONS => {
577             'BTRUE' => 18,
578             'NUMBER' => 19,
579             'UNQUOTED_STRING' => 21,
580             'BFALSE' => 22,
581             'QUOTED_STRING' => 20
582             },
583             GOTOS => {
584             'string' => 15,
585             'argument_list' => 16,
586             'argument' => 17
587             }
588             },
589             {#State 9
590             DEFAULT => -19
591             },
592             {#State 10
593             DEFAULT => -9
594             },
595             {#State 11
596             ACTIONS => {
597             'EOL' => 6,
598             'OPENBRAC' => 23,
599             'UNQUOTED_STRING' => 10
600             },
601             GOTOS => {
602             'statement' => 12,
603             'identifier' => 8,
604             'block_begin' => 2,
605             'block' => 7,
606             'option' => 1,
607             'block_end' => 24
608             }
609             },
610             {#State 12
611             DEFAULT => -18
612             },
613             {#State 13
614             DEFAULT => 0
615             },
616             {#State 14
617             ACTIONS => {
618             'CLOSEBRAC' => 26,
619             'BFALSE' => 22,
620             'UNQUOTED_STRING' => 21,
621             'QUOTED_STRING' => 20,
622             'NUMBER' => 19,
623             'BTRUE' => 18
624             },
625             GOTOS => {
626             'argument_list' => 25,
627             'string' => 15,
628             'argument' => 17
629             }
630             },
631             {#State 15
632             DEFAULT => -6
633             },
634             {#State 16
635             ACTIONS => {
636             'QUOTED_STRING' => 20,
637             'BFALSE' => 22,
638             'UNQUOTED_STRING' => 21,
639             'EOL' => 28,
640             'NUMBER' => 19,
641             'BTRUE' => 18
642             },
643             GOTOS => {
644             'argument' => 27,
645             'string' => 15
646             }
647             },
648             {#State 17
649             DEFAULT => -8
650             },
651             {#State 18
652             DEFAULT => -4
653             },
654             {#State 19
655             DEFAULT => -3
656             },
657             {#State 20
658             DEFAULT => -1
659             },
660             {#State 21
661             DEFAULT => -2
662             },
663             {#State 22
664             DEFAULT => -5
665             },
666             {#State 23
667             ACTIONS => {
668             'SLASH' => 29,
669             'UNQUOTED_STRING' => 10
670             },
671             GOTOS => {
672             'identifier' => 14
673             }
674             },
675             {#State 24
676             DEFAULT => -14
677             },
678             {#State 25
679             ACTIONS => {
680             'NUMBER' => 19,
681             'BTRUE' => 18,
682             'CLOSEBRAC' => 30,
683             'UNQUOTED_STRING' => 21,
684             'BFALSE' => 22,
685             'QUOTED_STRING' => 20
686             },
687             GOTOS => {
688             'argument' => 27,
689             'string' => 15
690             }
691             },
692             {#State 26
693             ACTIONS => {
694             'EOL' => 31
695             }
696             },
697             {#State 27
698             DEFAULT => -7
699             },
700             {#State 28
701             DEFAULT => -10
702             },
703             {#State 29
704             ACTIONS => {
705             'UNQUOTED_STRING' => 10
706             },
707             GOTOS => {
708             'identifier' => 32
709             }
710             },
711             {#State 30
712             ACTIONS => {
713             'EOL' => 33
714             }
715             },
716             {#State 31
717             DEFAULT => -11
718             },
719             {#State 32
720             ACTIONS => {
721             'CLOSEBRAC' => 34
722             }
723             },
724             {#State 33
725             DEFAULT => -12
726             },
727             {#State 34
728             ACTIONS => {
729             'EOL' => 35
730             }
731             },
732             {#State 35
733             DEFAULT => -13
734             }
735             ],
736             yyrules =>
737             [
738             [#Rule 0
739             '$start', 2, undef
740             ],
741             [#Rule 1
742             'string', 1,
743             sub
744             #line 62 "parser.yp"
745             { unquote ($_[1]);}
746             ],
747             [#Rule 2
748             'string', 1,
749             sub
750             #line 63 "parser.yp"
751             {$_[1];}
752             ],
753             [#Rule 3
754             'argument', 1,
755             sub
756             #line 67 "parser.yp"
757             {$_[1]}
758             ],
759             [#Rule 4
760             'argument', 1,
761             sub
762             #line 68 "parser.yp"
763             {1}
764             ],
765             [#Rule 5
766             'argument', 1,
767             sub
768             #line 69 "parser.yp"
769             {0}
770             ],
771             [#Rule 6
772             'argument', 1,
773             sub
774             #line 70 "parser.yp"
775             {$_[1]}
776             ],
777             [#Rule 7
778             'argument_list', 2,
779             sub
780             #line 75 "parser.yp"
781             {
782             my $argument_list = $_[1];
783             push @{ $argument_list->{values} }, $_[2];
784             return $argument_list;
785             }
786             ],
787             [#Rule 8
788             'argument_list', 1,
789             sub
790             #line 81 "parser.yp"
791             {
792             { values => [ $_[1] ] };
793             }
794             ],
795             [#Rule 9
796             'identifier', 1,
797             sub
798             #line 87 "parser.yp"
799             {$_[1]}
800             ],
801             [#Rule 10
802             'option', 3,
803             sub
804             #line 92 "parser.yp"
805             {
806             {
807             children => [],
808             key => $_[1],
809             %{$_[2]},
810             };
811             }
812             ],
813             [#Rule 11
814             'block_begin', 4,
815             sub
816             #line 103 "parser.yp"
817             {
818             {key => $_[2], values => []};
819             }
820             ],
821             [#Rule 12
822             'block_begin', 5,
823             sub
824             #line 108 "parser.yp"
825             {
826             {key => $_[2], %{$_[3]}};
827             }
828             ],
829             [#Rule 13
830             'block_end', 5,
831             sub
832             #line 115 "parser.yp"
833             {
834             $_[3];
835             }
836             ],
837             [#Rule 14
838             'block', 3,
839             sub
840             #line 122 "parser.yp"
841             {
842             if ($_[1]->{key} ne $_[3])
843             {
844             printf ("block_begin = %s; block_end = %s;\n", $_[1]->{key}, $_[3]);
845             YYERROR ("Block not closed..\n");
846             die;
847             }
848             return {
849             %{$_[1]},
850             children => $_[2],
851             };
852             }
853             ],
854             [#Rule 15
855             'statement', 1,
856             sub
857             #line 137 "parser.yp"
858             { $_[1] }
859             ],
860             [#Rule 16
861             'statement', 1,
862             sub
863             #line 138 "parser.yp"
864             { $_[1] }
865             ],
866             [#Rule 17
867             'statement', 1,
868             sub
869             #line 139 "parser.yp"
870             { return }
871             ],
872             [#Rule 18
873             'statement_list', 2,
874             sub
875             #line 144 "parser.yp"
876             {
877             my $statement_list = $_[1];
878             push @{ $statement_list }, $_[2] if defined $_[2];
879             return $statement_list;
880             }
881             ],
882             [#Rule 19
883             'statement_list', 1,
884             sub
885             #line 150 "parser.yp"
886             {
887             if (defined $_[1]) {
888             return [ $_[1] ];
889             } else {
890             return;
891             }
892             }
893             ],
894             [#Rule 20
895             'entire_file', 1,
896             sub
897             #line 161 "parser.yp"
898             {
899             $_[1]->[0];
900             }
901             ]
902             ],
903             @_);
904             bless($self,$class);
905             }
906              
907             #line 166 "parser.yp"
908              
909             sub unquote ($) {
910             (my $string = shift) =~ s/(?
911             return $string;
912             }
913              
914              
915             1;