File Coverage

blib/lib/MarpaX/Languages/ECMAScript/AST/Grammar/ECMAScript_262_5/Template.pm
Criterion Covered Total %
statement 6 1972 0.3
branch 0 1560 0.0
condition 0 2 0.0
subroutine 2 251 0.8
pod 247 247 100.0
total 255 4032 6.3


line stmt bran cond sub pod time code
1             #
2             # This is a generated file using the command:
3             # /usr/bin/perl script/generateTemplate.pl ECMAScript-262-5
4             #
5 1     1   7 use strict;
  1         2  
  1         37  
6 1     1   5 use warnings FATAL => 'all';
  1         2  
  1         23848  
7              
8             package MarpaX::Languages::ECMAScript::AST::Grammar::ECMAScript_262_5::Template;
9              
10             # ABSTRACT: Template for ECMAScript_262_5 transpilation using an AST
11              
12              
13             our $VERSION = '0.018'; # VERSION
14              
15              
16             sub new {
17 0     0 1   my ($class, $optionsp) = @_;
18              
19 0   0       $optionsp //= {};
20              
21             my $self = {
22             _nindent => 0,
23 0     0     _g1Callback => exists($optionsp->{g1Callback}) ? $optionsp->{g1Callback} : sub { return 1; },
24             _g1CallbackArgs => exists($optionsp->{g1CallbackArgs}) ? $optionsp->{g1CallbackArgs} : [],
25 0     0     _lexemeCallback => exists($optionsp->{lexemeCallback}) ? $optionsp->{lexemeCallback} : sub { return 0; },
26 0 0         _lexemeCallbackArgs => exists($optionsp->{lexemeCallbackArgs}) ? $optionsp->{lexemeCallbackArgs} : []
    0          
    0          
    0          
27             };
28 0           bless($self, $class);
29 0           return $self;
30             }
31              
32              
33             sub lexeme {
34 0     0 1   my $self = shift;
35              
36 0           my $rc = '';
37              
38 0 0         if (! &{$self->{_lexemeCallback}}(@{$self->{_lexemeCallbackArgs}}, \$rc, @_)) {
  0            
  0            
39              
40             # my ($name, $ruleId, $value, $index, $lhs, @rhs) = @_;
41              
42 0           my $lexeme = $_[2]->[2];
43 0 0         if ($lexeme eq ';') { $rc = " ;\n" . $self->indent(); }
  0 0          
    0          
44 0           elsif ($lexeme eq '{') { $rc = " {\n" . $self->indent(1); }
45 0           elsif ($lexeme eq '}') { $rc = "\n" . $self->indent(-1) . " }\n" . $self->indent();}
46 0           else { $rc = " $lexeme"; }
47             }
48              
49 0           return $rc;
50             }
51              
52              
53             sub indent {
54 0     0 1   my ($self, $inc) = @_;
55              
56 0 0         if (defined($inc)) {
57 0           $self->{_nindent} += $inc;
58             }
59              
60 0           return ' ' x $self->{_nindent};
61             }
62              
63              
64             sub transpile {
65 0     0 1   my ($self, $ast) = @_;
66              
67 0           my @worklist = ($ast);
68 0           my $transpile = '';
69 0           do {
70 0           my $obj = shift(@worklist);
71 0 0         if (ref($obj) eq 'HASH') {
72 0           my $g1 = 'G1_' . $obj->{ruleId};
73             # print STDERR "==> @{$obj->{values}}\n";
74 0           foreach (reverse 0..$#{$obj->{values}}) {
  0            
75 0           my $value = $obj->{values}->[$_];
76 0 0         if (ref($value) eq 'HASH') {
77             # print STDERR "Unshift $value\n";
78 0           unshift(@worklist, $value);
79             } else {
80             # print STDERR "Unshift [ $g1, $value, $_ ]\n";
81 0           unshift(@worklist, [ $g1, $value, $_ ]);
82             }
83             }
84             } else {
85 0           my ($curMethod, $value, $index) = @{$obj};
  0            
86             # print STDERR "==> Calling $curMethod($value, $index)\n";
87 0           $transpile .= $self->$curMethod($value, $index);
88             # print STDERR "==> $transpile\n";
89             }
90             } while (@worklist);
91              
92 0           return $transpile;
93              
94             # my ($ruleId, $value) = ($ast->{ruleId}, $ast->{values});
95             # my $method = "G1_$ruleId";
96             # return $self->$method($value);
97             }
98              
99              
100              
101             sub G1_0 {
102 0     0 1   my ($self, $value, $index) = @_;
103              
104 0           my $rc = '';
105              
106 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 0, $value, $index, 'Literal', 'NullLiteral')) {
  0            
  0            
107 0 0         if ($index == 0) {
108             }
109             }
110              
111 0           return $rc;
112             }
113              
114              
115              
116             sub G1_1 {
117 0     0 1   my ($self, $value, $index) = @_;
118              
119 0           my $rc = '';
120              
121 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 1, $value, $index, 'Literal', 'BooleanLiteral')) {
  0            
  0            
122 0 0         if ($index == 0) {
123             }
124             }
125              
126 0           return $rc;
127             }
128              
129              
130              
131             sub G1_2 {
132 0     0 1   my ($self, $value, $index) = @_;
133              
134 0           my $rc = '';
135              
136 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 2, $value, $index, 'Literal', 'NumericLiteral')) {
  0            
  0            
137 0 0         if ($index == 0) {
138             }
139             }
140              
141 0           return $rc;
142             }
143              
144              
145              
146             sub G1_3 {
147 0     0 1   my ($self, $value, $index) = @_;
148              
149 0           my $rc = '';
150              
151 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 3, $value, $index, 'Literal', 'StringLiteral')) {
  0            
  0            
152 0 0         if ($index == 0) {
153             }
154             }
155              
156 0           return $rc;
157             }
158              
159              
160              
161             sub G1_4 {
162 0     0 1   my ($self, $value, $index) = @_;
163              
164 0           my $rc = '';
165              
166 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 4, $value, $index, 'Literal', 'RegularExpressionLiteral')) {
  0            
  0            
167 0 0         if ($index == 0) {
168             }
169             }
170              
171 0           return $rc;
172             }
173              
174              
175              
176             sub G1_5 {
177 0     0 1   my ($self, $value, $index) = @_;
178              
179 0           my $rc = '';
180              
181 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 5, $value, $index, 'PrimaryExpression', 'THIS')) {
  0            
  0            
182 0 0         if ($index == 0) {
183 0           $rc = $self->lexeme('THIS', 5, $value, 0, 'PrimaryExpression', 'THIS');
184             }
185             }
186              
187 0           return $rc;
188             }
189              
190              
191              
192             sub G1_6 {
193 0     0 1   my ($self, $value, $index) = @_;
194              
195 0           my $rc = '';
196              
197 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 6, $value, $index, 'PrimaryExpression', 'IDENTIFIER')) {
  0            
  0            
198 0 0         if ($index == 0) {
199 0           $rc = $self->lexeme('IDENTIFIER', 6, $value, 0, 'PrimaryExpression', 'IDENTIFIER');
200             }
201             }
202              
203 0           return $rc;
204             }
205              
206              
207              
208             sub G1_7 {
209 0     0 1   my ($self, $value, $index) = @_;
210              
211 0           my $rc = '';
212              
213 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 7, $value, $index, 'PrimaryExpression', 'Literal')) {
  0            
  0            
214 0 0         if ($index == 0) {
215             }
216             }
217              
218 0           return $rc;
219             }
220              
221              
222              
223             sub G1_8 {
224 0     0 1   my ($self, $value, $index) = @_;
225              
226 0           my $rc = '';
227              
228 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 8, $value, $index, 'PrimaryExpression', 'ArrayLiteral')) {
  0            
  0            
229 0 0         if ($index == 0) {
230             }
231             }
232              
233 0           return $rc;
234             }
235              
236              
237              
238             sub G1_9 {
239 0     0 1   my ($self, $value, $index) = @_;
240              
241 0           my $rc = '';
242              
243 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 9, $value, $index, 'PrimaryExpression', 'ObjectLiteral')) {
  0            
  0            
244 0 0         if ($index == 0) {
245             }
246             }
247              
248 0           return $rc;
249             }
250              
251              
252              
253             sub G1_10 {
254 0     0 1   my ($self, $value, $index) = @_;
255              
256 0           my $rc = '';
257              
258 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 10, $value, $index, 'PrimaryExpression', 'LPAREN', 'Expression', 'RPAREN')) {
  0            
  0            
259 0 0         if ($index == 0) {
    0          
    0          
260 0           $rc = $self->lexeme('LPAREN', 10, $value, 0, 'PrimaryExpression', 'LPAREN', 'Expression', 'RPAREN');
261             }
262             elsif ($index == 1) {
263             }
264             elsif ($index == 2) {
265 0           $rc = $self->lexeme('RPAREN', 10, $value, 2, 'PrimaryExpression', 'LPAREN', 'Expression', 'RPAREN');
266             }
267             }
268              
269 0           return $rc;
270             }
271              
272              
273              
274             sub G1_11 {
275 0     0 1   my ($self, $value, $index) = @_;
276              
277 0           my $rc = '';
278              
279 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 11, $value, $index, 'ArrayLiteral', 'LBRACKET', 'Elisionopt', 'RBRACKET')) {
  0            
  0            
280 0 0         if ($index == 0) {
    0          
    0          
281 0           $rc = $self->lexeme('LBRACKET', 11, $value, 0, 'ArrayLiteral', 'LBRACKET', 'Elisionopt', 'RBRACKET');
282             }
283             elsif ($index == 1) {
284             }
285             elsif ($index == 2) {
286 0           $rc = $self->lexeme('RBRACKET', 11, $value, 2, 'ArrayLiteral', 'LBRACKET', 'Elisionopt', 'RBRACKET');
287             }
288             }
289              
290 0           return $rc;
291             }
292              
293              
294              
295             sub G1_12 {
296 0     0 1   my ($self, $value, $index) = @_;
297              
298 0           my $rc = '';
299              
300 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 12, $value, $index, 'ArrayLiteral', 'LBRACKET', 'ElementList', 'RBRACKET')) {
  0            
  0            
301 0 0         if ($index == 0) {
    0          
    0          
302 0           $rc = $self->lexeme('LBRACKET', 12, $value, 0, 'ArrayLiteral', 'LBRACKET', 'ElementList', 'RBRACKET');
303             }
304             elsif ($index == 1) {
305             }
306             elsif ($index == 2) {
307 0           $rc = $self->lexeme('RBRACKET', 12, $value, 2, 'ArrayLiteral', 'LBRACKET', 'ElementList', 'RBRACKET');
308             }
309             }
310              
311 0           return $rc;
312             }
313              
314              
315              
316             sub G1_13 {
317 0     0 1   my ($self, $value, $index) = @_;
318              
319 0           my $rc = '';
320              
321 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 13, $value, $index, 'ArrayLiteral', 'LBRACKET', 'ElementList', 'COMMA', 'Elisionopt', 'RBRACKET')) {
  0            
  0            
322 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
323 0           $rc = $self->lexeme('LBRACKET', 13, $value, 0, 'ArrayLiteral', 'LBRACKET', 'ElementList', 'COMMA', 'Elisionopt', 'RBRACKET');
324             }
325             elsif ($index == 1) {
326             }
327             elsif ($index == 2) {
328 0           $rc = $self->lexeme('COMMA', 13, $value, 2, 'ArrayLiteral', 'LBRACKET', 'ElementList', 'COMMA', 'Elisionopt', 'RBRACKET');
329             }
330             elsif ($index == 3) {
331             }
332             elsif ($index == 4) {
333 0           $rc = $self->lexeme('RBRACKET', 13, $value, 4, 'ArrayLiteral', 'LBRACKET', 'ElementList', 'COMMA', 'Elisionopt', 'RBRACKET');
334             }
335             }
336              
337 0           return $rc;
338             }
339              
340              
341              
342             sub G1_14 {
343 0     0 1   my ($self, $value, $index) = @_;
344              
345 0           my $rc = '';
346              
347 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 14, $value, $index, 'ElementList', 'Elisionopt', 'AssignmentExpression')) {
  0            
  0            
348 0 0         if ($index == 0) {
    0          
349             }
350             elsif ($index == 1) {
351             }
352             }
353              
354 0           return $rc;
355             }
356              
357              
358              
359             sub G1_15 {
360 0     0 1   my ($self, $value, $index) = @_;
361              
362 0           my $rc = '';
363              
364 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 15, $value, $index, 'ElementList', 'ElementList', 'COMMA', 'Elisionopt', 'AssignmentExpression')) {
  0            
  0            
365 0 0         if ($index == 0) {
    0          
    0          
    0          
366             }
367             elsif ($index == 1) {
368 0           $rc = $self->lexeme('COMMA', 15, $value, 1, 'ElementList', 'ElementList', 'COMMA', 'Elisionopt', 'AssignmentExpression');
369             }
370             elsif ($index == 2) {
371             }
372             elsif ($index == 3) {
373             }
374             }
375              
376 0           return $rc;
377             }
378              
379              
380              
381             sub G1_16 {
382 0     0 1   my ($self, $value, $index) = @_;
383              
384 0           my $rc = '';
385              
386 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 16, $value, $index, 'Elision', 'COMMA')) {
  0            
  0            
387 0 0         if ($index == 0) {
388 0           $rc = $self->lexeme('COMMA', 16, $value, 0, 'Elision', 'COMMA');
389             }
390             }
391              
392 0           return $rc;
393             }
394              
395              
396              
397             sub G1_17 {
398 0     0 1   my ($self, $value, $index) = @_;
399              
400 0           my $rc = '';
401              
402 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 17, $value, $index, 'Elision', 'Elision', 'COMMA')) {
  0            
  0            
403 0 0         if ($index == 0) {
    0          
404             }
405             elsif ($index == 1) {
406 0           $rc = $self->lexeme('COMMA', 17, $value, 1, 'Elision', 'Elision', 'COMMA');
407             }
408             }
409              
410 0           return $rc;
411             }
412              
413              
414              
415             sub G1_18 {
416 0     0 1   my ($self, $value, $index) = @_;
417              
418 0           my $rc = '';
419              
420 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 18, $value, $index, 'Elisionopt', 'Elision')) {
  0            
  0            
421 0 0         if ($index == 0) {
422             }
423             }
424              
425 0           return $rc;
426             }
427              
428              
429              
430             sub G1_19 {
431 0     0 1   my ($self, $value, $index) = @_;
432              
433 0           my $rc = '';
434              
435 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 19, $value, $index, 'Elisionopt', )) {
  0            
  0            
436             }
437              
438 0           return $rc;
439             }
440              
441              
442              
443             sub G1_20 {
444 0     0 1   my ($self, $value, $index) = @_;
445              
446 0           my $rc = '';
447              
448 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 20, $value, $index, 'ObjectLiteral', 'LCURLY', 'RCURLY')) {
  0            
  0            
449 0 0         if ($index == 0) {
    0          
450 0           $rc = $self->lexeme('LCURLY', 20, $value, 0, 'ObjectLiteral', 'LCURLY', 'RCURLY');
451             }
452             elsif ($index == 1) {
453 0           $rc = $self->lexeme('RCURLY', 20, $value, 1, 'ObjectLiteral', 'LCURLY', 'RCURLY');
454             }
455             }
456              
457 0           return $rc;
458             }
459              
460              
461              
462             sub G1_21 {
463 0     0 1   my ($self, $value, $index) = @_;
464              
465 0           my $rc = '';
466              
467 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 21, $value, $index, 'ObjectLiteral', 'LCURLY', 'PropertyNameAndValueList', 'RCURLY')) {
  0            
  0            
468 0 0         if ($index == 0) {
    0          
    0          
469 0           $rc = $self->lexeme('LCURLY', 21, $value, 0, 'ObjectLiteral', 'LCURLY', 'PropertyNameAndValueList', 'RCURLY');
470             }
471             elsif ($index == 1) {
472             }
473             elsif ($index == 2) {
474 0           $rc = $self->lexeme('RCURLY', 21, $value, 2, 'ObjectLiteral', 'LCURLY', 'PropertyNameAndValueList', 'RCURLY');
475             }
476             }
477              
478 0           return $rc;
479             }
480              
481              
482              
483             sub G1_22 {
484 0     0 1   my ($self, $value, $index) = @_;
485              
486 0           my $rc = '';
487              
488 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 22, $value, $index, 'ObjectLiteral', 'LCURLY', 'PropertyNameAndValueList', 'COMMA', 'RCURLY')) {
  0            
  0            
489 0 0         if ($index == 0) {
    0          
    0          
    0          
490 0           $rc = $self->lexeme('LCURLY', 22, $value, 0, 'ObjectLiteral', 'LCURLY', 'PropertyNameAndValueList', 'COMMA', 'RCURLY');
491             }
492             elsif ($index == 1) {
493             }
494             elsif ($index == 2) {
495 0           $rc = $self->lexeme('COMMA', 22, $value, 2, 'ObjectLiteral', 'LCURLY', 'PropertyNameAndValueList', 'COMMA', 'RCURLY');
496             }
497             elsif ($index == 3) {
498 0           $rc = $self->lexeme('RCURLY', 22, $value, 3, 'ObjectLiteral', 'LCURLY', 'PropertyNameAndValueList', 'COMMA', 'RCURLY');
499             }
500             }
501              
502 0           return $rc;
503             }
504              
505              
506              
507             sub G1_23 {
508 0     0 1   my ($self, $value, $index) = @_;
509              
510 0           my $rc = '';
511              
512 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 23, $value, $index, 'PropertyNameAndValueList', 'PropertyAssignment')) {
  0            
  0            
513 0 0         if ($index == 0) {
514             }
515             }
516              
517 0           return $rc;
518             }
519              
520              
521              
522             sub G1_24 {
523 0     0 1   my ($self, $value, $index) = @_;
524              
525 0           my $rc = '';
526              
527 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 24, $value, $index, 'PropertyNameAndValueList', 'PropertyNameAndValueList', 'COMMA', 'PropertyAssignment')) {
  0            
  0            
528 0 0         if ($index == 0) {
    0          
    0          
529             }
530             elsif ($index == 1) {
531 0           $rc = $self->lexeme('COMMA', 24, $value, 1, 'PropertyNameAndValueList', 'PropertyNameAndValueList', 'COMMA', 'PropertyAssignment');
532             }
533             elsif ($index == 2) {
534             }
535             }
536              
537 0           return $rc;
538             }
539              
540              
541              
542             sub G1_25 {
543 0     0 1   my ($self, $value, $index) = @_;
544              
545 0           my $rc = '';
546              
547 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 25, $value, $index, 'PropertyAssignment', 'PropertyName', 'COLON', 'AssignmentExpression')) {
  0            
  0            
548 0 0         if ($index == 0) {
    0          
    0          
549             }
550             elsif ($index == 1) {
551 0           $rc = $self->lexeme('COLON', 25, $value, 1, 'PropertyAssignment', 'PropertyName', 'COLON', 'AssignmentExpression');
552             }
553             elsif ($index == 2) {
554             }
555             }
556              
557 0           return $rc;
558             }
559              
560              
561              
562             sub G1_26 {
563 0     0 1   my ($self, $value, $index) = @_;
564              
565 0           my $rc = '';
566              
567 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 26, $value, $index, 'PropertyAssignment', 'GET', 'PropertyName', 'LPAREN', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY')) {
  0            
  0            
568 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
    0          
    0          
569 0           $rc = $self->lexeme('GET', 26, $value, 0, 'PropertyAssignment', 'GET', 'PropertyName', 'LPAREN', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
570             }
571             elsif ($index == 1) {
572             }
573             elsif ($index == 2) {
574 0           $rc = $self->lexeme('LPAREN', 26, $value, 2, 'PropertyAssignment', 'GET', 'PropertyName', 'LPAREN', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
575             }
576             elsif ($index == 3) {
577 0           $rc = $self->lexeme('RPAREN', 26, $value, 3, 'PropertyAssignment', 'GET', 'PropertyName', 'LPAREN', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
578             }
579             elsif ($index == 4) {
580 0           $rc = $self->lexeme('LCURLY', 26, $value, 4, 'PropertyAssignment', 'GET', 'PropertyName', 'LPAREN', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
581             }
582             elsif ($index == 5) {
583             }
584             elsif ($index == 6) {
585 0           $rc = $self->lexeme('RCURLY', 26, $value, 6, 'PropertyAssignment', 'GET', 'PropertyName', 'LPAREN', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
586             }
587             }
588              
589 0           return $rc;
590             }
591              
592              
593              
594             sub G1_27 {
595 0     0 1   my ($self, $value, $index) = @_;
596              
597 0           my $rc = '';
598              
599 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 27, $value, $index, 'PropertyAssignment', 'SET', 'PropertyName', 'LPAREN', 'PropertySetParameterList', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY')) {
  0            
  0            
600 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
    0          
    0          
    0          
601 0           $rc = $self->lexeme('SET', 27, $value, 0, 'PropertyAssignment', 'SET', 'PropertyName', 'LPAREN', 'PropertySetParameterList', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
602             }
603             elsif ($index == 1) {
604             }
605             elsif ($index == 2) {
606 0           $rc = $self->lexeme('LPAREN', 27, $value, 2, 'PropertyAssignment', 'SET', 'PropertyName', 'LPAREN', 'PropertySetParameterList', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
607             }
608             elsif ($index == 3) {
609             }
610             elsif ($index == 4) {
611 0           $rc = $self->lexeme('RPAREN', 27, $value, 4, 'PropertyAssignment', 'SET', 'PropertyName', 'LPAREN', 'PropertySetParameterList', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
612             }
613             elsif ($index == 5) {
614 0           $rc = $self->lexeme('LCURLY', 27, $value, 5, 'PropertyAssignment', 'SET', 'PropertyName', 'LPAREN', 'PropertySetParameterList', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
615             }
616             elsif ($index == 6) {
617             }
618             elsif ($index == 7) {
619 0           $rc = $self->lexeme('RCURLY', 27, $value, 7, 'PropertyAssignment', 'SET', 'PropertyName', 'LPAREN', 'PropertySetParameterList', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
620             }
621             }
622              
623 0           return $rc;
624             }
625              
626              
627              
628             sub G1_28 {
629 0     0 1   my ($self, $value, $index) = @_;
630              
631 0           my $rc = '';
632              
633 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 28, $value, $index, 'PropertyName', 'IDENTIFIERNAME')) {
  0            
  0            
634 0 0         if ($index == 0) {
635 0           $rc = $self->lexeme('IDENTIFIERNAME', 28, $value, 0, 'PropertyName', 'IDENTIFIERNAME');
636             }
637             }
638              
639 0           return $rc;
640             }
641              
642              
643              
644             sub G1_29 {
645 0     0 1   my ($self, $value, $index) = @_;
646              
647 0           my $rc = '';
648              
649 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 29, $value, $index, 'PropertyName', 'StringLiteral')) {
  0            
  0            
650 0 0         if ($index == 0) {
651             }
652             }
653              
654 0           return $rc;
655             }
656              
657              
658              
659             sub G1_30 {
660 0     0 1   my ($self, $value, $index) = @_;
661              
662 0           my $rc = '';
663              
664 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 30, $value, $index, 'PropertyName', 'NumericLiteral')) {
  0            
  0            
665 0 0         if ($index == 0) {
666             }
667             }
668              
669 0           return $rc;
670             }
671              
672              
673              
674             sub G1_31 {
675 0     0 1   my ($self, $value, $index) = @_;
676              
677 0           my $rc = '';
678              
679 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 31, $value, $index, 'PropertySetParameterList', 'IDENTIFIER')) {
  0            
  0            
680 0 0         if ($index == 0) {
681 0           $rc = $self->lexeme('IDENTIFIER', 31, $value, 0, 'PropertySetParameterList', 'IDENTIFIER');
682             }
683             }
684              
685 0           return $rc;
686             }
687              
688              
689              
690             sub G1_32 {
691 0     0 1   my ($self, $value, $index) = @_;
692              
693 0           my $rc = '';
694              
695 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 32, $value, $index, 'MemberExpression', 'PrimaryExpression')) {
  0            
  0            
696 0 0         if ($index == 0) {
697             }
698             }
699              
700 0           return $rc;
701             }
702              
703              
704              
705             sub G1_33 {
706 0     0 1   my ($self, $value, $index) = @_;
707              
708 0           my $rc = '';
709              
710 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 33, $value, $index, 'MemberExpression', 'FunctionExpression')) {
  0            
  0            
711 0 0         if ($index == 0) {
712             }
713             }
714              
715 0           return $rc;
716             }
717              
718              
719              
720             sub G1_34 {
721 0     0 1   my ($self, $value, $index) = @_;
722              
723 0           my $rc = '';
724              
725 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 34, $value, $index, 'MemberExpression', 'MemberExpression', 'LBRACKET', 'Expression', 'RBRACKET')) {
  0            
  0            
726 0 0         if ($index == 0) {
    0          
    0          
    0          
727             }
728             elsif ($index == 1) {
729 0           $rc = $self->lexeme('LBRACKET', 34, $value, 1, 'MemberExpression', 'MemberExpression', 'LBRACKET', 'Expression', 'RBRACKET');
730             }
731             elsif ($index == 2) {
732             }
733             elsif ($index == 3) {
734 0           $rc = $self->lexeme('RBRACKET', 34, $value, 3, 'MemberExpression', 'MemberExpression', 'LBRACKET', 'Expression', 'RBRACKET');
735             }
736             }
737              
738 0           return $rc;
739             }
740              
741              
742              
743             sub G1_35 {
744 0     0 1   my ($self, $value, $index) = @_;
745              
746 0           my $rc = '';
747              
748 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 35, $value, $index, 'MemberExpression', 'MemberExpression', 'DOT', 'IDENTIFIERNAME')) {
  0            
  0            
749 0 0         if ($index == 0) {
    0          
    0          
750             }
751             elsif ($index == 1) {
752 0           $rc = $self->lexeme('DOT', 35, $value, 1, 'MemberExpression', 'MemberExpression', 'DOT', 'IDENTIFIERNAME');
753             }
754             elsif ($index == 2) {
755 0           $rc = $self->lexeme('IDENTIFIERNAME', 35, $value, 2, 'MemberExpression', 'MemberExpression', 'DOT', 'IDENTIFIERNAME');
756             }
757             }
758              
759 0           return $rc;
760             }
761              
762              
763              
764             sub G1_36 {
765 0     0 1   my ($self, $value, $index) = @_;
766              
767 0           my $rc = '';
768              
769 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 36, $value, $index, 'MemberExpression', 'NEW', 'MemberExpression', 'Arguments')) {
  0            
  0            
770 0 0         if ($index == 0) {
    0          
    0          
771 0           $rc = $self->lexeme('NEW', 36, $value, 0, 'MemberExpression', 'NEW', 'MemberExpression', 'Arguments');
772             }
773             elsif ($index == 1) {
774             }
775             elsif ($index == 2) {
776             }
777             }
778              
779 0           return $rc;
780             }
781              
782              
783              
784             sub G1_37 {
785 0     0 1   my ($self, $value, $index) = @_;
786              
787 0           my $rc = '';
788              
789 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 37, $value, $index, 'NewExpression', 'MemberExpression')) {
  0            
  0            
790 0 0         if ($index == 0) {
791             }
792             }
793              
794 0           return $rc;
795             }
796              
797              
798              
799             sub G1_38 {
800 0     0 1   my ($self, $value, $index) = @_;
801              
802 0           my $rc = '';
803              
804 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 38, $value, $index, 'NewExpression', 'NEW', 'NewExpression')) {
  0            
  0            
805 0 0         if ($index == 0) {
    0          
806 0           $rc = $self->lexeme('NEW', 38, $value, 0, 'NewExpression', 'NEW', 'NewExpression');
807             }
808             elsif ($index == 1) {
809             }
810             }
811              
812 0           return $rc;
813             }
814              
815              
816              
817             sub G1_39 {
818 0     0 1   my ($self, $value, $index) = @_;
819              
820 0           my $rc = '';
821              
822 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 39, $value, $index, 'CallExpression', 'MemberExpression', 'Arguments')) {
  0            
  0            
823 0 0         if ($index == 0) {
    0          
824             }
825             elsif ($index == 1) {
826             }
827             }
828              
829 0           return $rc;
830             }
831              
832              
833              
834             sub G1_40 {
835 0     0 1   my ($self, $value, $index) = @_;
836              
837 0           my $rc = '';
838              
839 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 40, $value, $index, 'CallExpression', 'CallExpression', 'Arguments')) {
  0            
  0            
840 0 0         if ($index == 0) {
    0          
841             }
842             elsif ($index == 1) {
843             }
844             }
845              
846 0           return $rc;
847             }
848              
849              
850              
851             sub G1_41 {
852 0     0 1   my ($self, $value, $index) = @_;
853              
854 0           my $rc = '';
855              
856 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 41, $value, $index, 'CallExpression', 'CallExpression', 'LBRACKET', 'Expression', 'RBRACKET')) {
  0            
  0            
857 0 0         if ($index == 0) {
    0          
    0          
    0          
858             }
859             elsif ($index == 1) {
860 0           $rc = $self->lexeme('LBRACKET', 41, $value, 1, 'CallExpression', 'CallExpression', 'LBRACKET', 'Expression', 'RBRACKET');
861             }
862             elsif ($index == 2) {
863             }
864             elsif ($index == 3) {
865 0           $rc = $self->lexeme('RBRACKET', 41, $value, 3, 'CallExpression', 'CallExpression', 'LBRACKET', 'Expression', 'RBRACKET');
866             }
867             }
868              
869 0           return $rc;
870             }
871              
872              
873              
874             sub G1_42 {
875 0     0 1   my ($self, $value, $index) = @_;
876              
877 0           my $rc = '';
878              
879 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 42, $value, $index, 'CallExpression', 'CallExpression', 'DOT', 'IDENTIFIERNAME')) {
  0            
  0            
880 0 0         if ($index == 0) {
    0          
    0          
881             }
882             elsif ($index == 1) {
883 0           $rc = $self->lexeme('DOT', 42, $value, 1, 'CallExpression', 'CallExpression', 'DOT', 'IDENTIFIERNAME');
884             }
885             elsif ($index == 2) {
886 0           $rc = $self->lexeme('IDENTIFIERNAME', 42, $value, 2, 'CallExpression', 'CallExpression', 'DOT', 'IDENTIFIERNAME');
887             }
888             }
889              
890 0           return $rc;
891             }
892              
893              
894              
895             sub G1_43 {
896 0     0 1   my ($self, $value, $index) = @_;
897              
898 0           my $rc = '';
899              
900 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 43, $value, $index, 'Arguments', 'LPAREN', 'RPAREN')) {
  0            
  0            
901 0 0         if ($index == 0) {
    0          
902 0           $rc = $self->lexeme('LPAREN', 43, $value, 0, 'Arguments', 'LPAREN', 'RPAREN');
903             }
904             elsif ($index == 1) {
905 0           $rc = $self->lexeme('RPAREN', 43, $value, 1, 'Arguments', 'LPAREN', 'RPAREN');
906             }
907             }
908              
909 0           return $rc;
910             }
911              
912              
913              
914             sub G1_44 {
915 0     0 1   my ($self, $value, $index) = @_;
916              
917 0           my $rc = '';
918              
919 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 44, $value, $index, 'Arguments', 'LPAREN', 'ArgumentList', 'RPAREN')) {
  0            
  0            
920 0 0         if ($index == 0) {
    0          
    0          
921 0           $rc = $self->lexeme('LPAREN', 44, $value, 0, 'Arguments', 'LPAREN', 'ArgumentList', 'RPAREN');
922             }
923             elsif ($index == 1) {
924             }
925             elsif ($index == 2) {
926 0           $rc = $self->lexeme('RPAREN', 44, $value, 2, 'Arguments', 'LPAREN', 'ArgumentList', 'RPAREN');
927             }
928             }
929              
930 0           return $rc;
931             }
932              
933              
934              
935             sub G1_45 {
936 0     0 1   my ($self, $value, $index) = @_;
937              
938 0           my $rc = '';
939              
940 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 45, $value, $index, 'ArgumentList', 'AssignmentExpression')) {
  0            
  0            
941 0 0         if ($index == 0) {
942             }
943             }
944              
945 0           return $rc;
946             }
947              
948              
949              
950             sub G1_46 {
951 0     0 1   my ($self, $value, $index) = @_;
952              
953 0           my $rc = '';
954              
955 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 46, $value, $index, 'ArgumentList', 'ArgumentList', 'COMMA', 'AssignmentExpression')) {
  0            
  0            
956 0 0         if ($index == 0) {
    0          
    0          
957             }
958             elsif ($index == 1) {
959 0           $rc = $self->lexeme('COMMA', 46, $value, 1, 'ArgumentList', 'ArgumentList', 'COMMA', 'AssignmentExpression');
960             }
961             elsif ($index == 2) {
962             }
963             }
964              
965 0           return $rc;
966             }
967              
968              
969              
970             sub G1_47 {
971 0     0 1   my ($self, $value, $index) = @_;
972              
973 0           my $rc = '';
974              
975 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 47, $value, $index, 'LeftHandSideExpression', 'NewExpression')) {
  0            
  0            
976 0 0         if ($index == 0) {
977             }
978             }
979              
980 0           return $rc;
981             }
982              
983              
984              
985             sub G1_48 {
986 0     0 1   my ($self, $value, $index) = @_;
987              
988 0           my $rc = '';
989              
990 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 48, $value, $index, 'LeftHandSideExpression', 'CallExpression')) {
  0            
  0            
991 0 0         if ($index == 0) {
992             }
993             }
994              
995 0           return $rc;
996             }
997              
998              
999              
1000             sub G1_49 {
1001 0     0 1   my ($self, $value, $index) = @_;
1002              
1003 0           my $rc = '';
1004              
1005 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 49, $value, $index, 'PostfixExpression', 'LeftHandSideExpression')) {
  0            
  0            
1006 0 0         if ($index == 0) {
1007             }
1008             }
1009              
1010 0           return $rc;
1011             }
1012              
1013              
1014              
1015             sub G1_50 {
1016 0     0 1   my ($self, $value, $index) = @_;
1017              
1018 0           my $rc = '';
1019              
1020 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 50, $value, $index, 'PostfixExpression', 'LeftHandSideExpression', 'PLUSPLUS_POSTFIX')) {
  0            
  0            
1021 0 0         if ($index == 0) {
    0          
1022             }
1023             elsif ($index == 1) {
1024 0           $rc = $self->lexeme('PLUSPLUS_POSTFIX', 50, $value, 1, 'PostfixExpression', 'LeftHandSideExpression', 'PLUSPLUS_POSTFIX');
1025             }
1026             }
1027              
1028 0           return $rc;
1029             }
1030              
1031              
1032              
1033             sub G1_51 {
1034 0     0 1   my ($self, $value, $index) = @_;
1035              
1036 0           my $rc = '';
1037              
1038 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 51, $value, $index, 'PostfixExpression', 'LeftHandSideExpression', 'MINUSMINUS_POSTFIX')) {
  0            
  0            
1039 0 0         if ($index == 0) {
    0          
1040             }
1041             elsif ($index == 1) {
1042 0           $rc = $self->lexeme('MINUSMINUS_POSTFIX', 51, $value, 1, 'PostfixExpression', 'LeftHandSideExpression', 'MINUSMINUS_POSTFIX');
1043             }
1044             }
1045              
1046 0           return $rc;
1047             }
1048              
1049              
1050              
1051             sub G1_52 {
1052 0     0 1   my ($self, $value, $index) = @_;
1053              
1054 0           my $rc = '';
1055              
1056 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 52, $value, $index, 'UnaryExpression', 'PostfixExpression')) {
  0            
  0            
1057 0 0         if ($index == 0) {
1058             }
1059             }
1060              
1061 0           return $rc;
1062             }
1063              
1064              
1065              
1066             sub G1_53 {
1067 0     0 1   my ($self, $value, $index) = @_;
1068              
1069 0           my $rc = '';
1070              
1071 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 53, $value, $index, 'UnaryExpression', 'DELETE', 'UnaryExpression')) {
  0            
  0            
1072 0 0         if ($index == 0) {
    0          
1073 0           $rc = $self->lexeme('DELETE', 53, $value, 0, 'UnaryExpression', 'DELETE', 'UnaryExpression');
1074             }
1075             elsif ($index == 1) {
1076             }
1077             }
1078              
1079 0           return $rc;
1080             }
1081              
1082              
1083              
1084             sub G1_54 {
1085 0     0 1   my ($self, $value, $index) = @_;
1086              
1087 0           my $rc = '';
1088              
1089 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 54, $value, $index, 'UnaryExpression', 'VOID', 'UnaryExpression')) {
  0            
  0            
1090 0 0         if ($index == 0) {
    0          
1091 0           $rc = $self->lexeme('VOID', 54, $value, 0, 'UnaryExpression', 'VOID', 'UnaryExpression');
1092             }
1093             elsif ($index == 1) {
1094             }
1095             }
1096              
1097 0           return $rc;
1098             }
1099              
1100              
1101              
1102             sub G1_55 {
1103 0     0 1   my ($self, $value, $index) = @_;
1104              
1105 0           my $rc = '';
1106              
1107 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 55, $value, $index, 'UnaryExpression', 'TYPEOF', 'UnaryExpression')) {
  0            
  0            
1108 0 0         if ($index == 0) {
    0          
1109 0           $rc = $self->lexeme('TYPEOF', 55, $value, 0, 'UnaryExpression', 'TYPEOF', 'UnaryExpression');
1110             }
1111             elsif ($index == 1) {
1112             }
1113             }
1114              
1115 0           return $rc;
1116             }
1117              
1118              
1119              
1120             sub G1_56 {
1121 0     0 1   my ($self, $value, $index) = @_;
1122              
1123 0           my $rc = '';
1124              
1125 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 56, $value, $index, 'UnaryExpression', 'PLUSPLUS', 'UnaryExpression')) {
  0            
  0            
1126 0 0         if ($index == 0) {
    0          
1127 0           $rc = $self->lexeme('PLUSPLUS', 56, $value, 0, 'UnaryExpression', 'PLUSPLUS', 'UnaryExpression');
1128             }
1129             elsif ($index == 1) {
1130             }
1131             }
1132              
1133 0           return $rc;
1134             }
1135              
1136              
1137              
1138             sub G1_57 {
1139 0     0 1   my ($self, $value, $index) = @_;
1140              
1141 0           my $rc = '';
1142              
1143 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 57, $value, $index, 'UnaryExpression', 'MINUSMINUS', 'UnaryExpression')) {
  0            
  0            
1144 0 0         if ($index == 0) {
    0          
1145 0           $rc = $self->lexeme('MINUSMINUS', 57, $value, 0, 'UnaryExpression', 'MINUSMINUS', 'UnaryExpression');
1146             }
1147             elsif ($index == 1) {
1148             }
1149             }
1150              
1151 0           return $rc;
1152             }
1153              
1154              
1155              
1156             sub G1_58 {
1157 0     0 1   my ($self, $value, $index) = @_;
1158              
1159 0           my $rc = '';
1160              
1161 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 58, $value, $index, 'UnaryExpression', 'PLUS', 'UnaryExpression')) {
  0            
  0            
1162 0 0         if ($index == 0) {
    0          
1163 0           $rc = $self->lexeme('PLUS', 58, $value, 0, 'UnaryExpression', 'PLUS', 'UnaryExpression');
1164             }
1165             elsif ($index == 1) {
1166             }
1167             }
1168              
1169 0           return $rc;
1170             }
1171              
1172              
1173              
1174             sub G1_59 {
1175 0     0 1   my ($self, $value, $index) = @_;
1176              
1177 0           my $rc = '';
1178              
1179 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 59, $value, $index, 'UnaryExpression', 'MINUS', 'UnaryExpression')) {
  0            
  0            
1180 0 0         if ($index == 0) {
    0          
1181 0           $rc = $self->lexeme('MINUS', 59, $value, 0, 'UnaryExpression', 'MINUS', 'UnaryExpression');
1182             }
1183             elsif ($index == 1) {
1184             }
1185             }
1186              
1187 0           return $rc;
1188             }
1189              
1190              
1191              
1192             sub G1_60 {
1193 0     0 1   my ($self, $value, $index) = @_;
1194              
1195 0           my $rc = '';
1196              
1197 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 60, $value, $index, 'UnaryExpression', 'INVERT', 'UnaryExpression')) {
  0            
  0            
1198 0 0         if ($index == 0) {
    0          
1199 0           $rc = $self->lexeme('INVERT', 60, $value, 0, 'UnaryExpression', 'INVERT', 'UnaryExpression');
1200             }
1201             elsif ($index == 1) {
1202             }
1203             }
1204              
1205 0           return $rc;
1206             }
1207              
1208              
1209              
1210             sub G1_61 {
1211 0     0 1   my ($self, $value, $index) = @_;
1212              
1213 0           my $rc = '';
1214              
1215 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 61, $value, $index, 'UnaryExpression', 'NOT', 'UnaryExpression')) {
  0            
  0            
1216 0 0         if ($index == 0) {
    0          
1217 0           $rc = $self->lexeme('NOT', 61, $value, 0, 'UnaryExpression', 'NOT', 'UnaryExpression');
1218             }
1219             elsif ($index == 1) {
1220             }
1221             }
1222              
1223 0           return $rc;
1224             }
1225              
1226              
1227              
1228             sub G1_62 {
1229 0     0 1   my ($self, $value, $index) = @_;
1230              
1231 0           my $rc = '';
1232              
1233 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 62, $value, $index, 'MultiplicativeExpression', 'UnaryExpression')) {
  0            
  0            
1234 0 0         if ($index == 0) {
1235             }
1236             }
1237              
1238 0           return $rc;
1239             }
1240              
1241              
1242              
1243             sub G1_63 {
1244 0     0 1   my ($self, $value, $index) = @_;
1245              
1246 0           my $rc = '';
1247              
1248 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 63, $value, $index, 'MultiplicativeExpression', 'MultiplicativeExpression', 'MUL', 'UnaryExpression')) {
  0            
  0            
1249 0 0         if ($index == 0) {
    0          
    0          
1250             }
1251             elsif ($index == 1) {
1252 0           $rc = $self->lexeme('MUL', 63, $value, 1, 'MultiplicativeExpression', 'MultiplicativeExpression', 'MUL', 'UnaryExpression');
1253             }
1254             elsif ($index == 2) {
1255             }
1256             }
1257              
1258 0           return $rc;
1259             }
1260              
1261              
1262              
1263             sub G1_64 {
1264 0     0 1   my ($self, $value, $index) = @_;
1265              
1266 0           my $rc = '';
1267              
1268 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 64, $value, $index, 'MultiplicativeExpression', 'MultiplicativeExpression', 'DIV', 'UnaryExpression')) {
  0            
  0            
1269 0 0         if ($index == 0) {
    0          
    0          
1270             }
1271             elsif ($index == 1) {
1272 0           $rc = $self->lexeme('DIV', 64, $value, 1, 'MultiplicativeExpression', 'MultiplicativeExpression', 'DIV', 'UnaryExpression');
1273             }
1274             elsif ($index == 2) {
1275             }
1276             }
1277              
1278 0           return $rc;
1279             }
1280              
1281              
1282              
1283             sub G1_65 {
1284 0     0 1   my ($self, $value, $index) = @_;
1285              
1286 0           my $rc = '';
1287              
1288 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 65, $value, $index, 'MultiplicativeExpression', 'MultiplicativeExpression', 'MODULUS', 'UnaryExpression')) {
  0            
  0            
1289 0 0         if ($index == 0) {
    0          
    0          
1290             }
1291             elsif ($index == 1) {
1292 0           $rc = $self->lexeme('MODULUS', 65, $value, 1, 'MultiplicativeExpression', 'MultiplicativeExpression', 'MODULUS', 'UnaryExpression');
1293             }
1294             elsif ($index == 2) {
1295             }
1296             }
1297              
1298 0           return $rc;
1299             }
1300              
1301              
1302              
1303             sub G1_66 {
1304 0     0 1   my ($self, $value, $index) = @_;
1305              
1306 0           my $rc = '';
1307              
1308 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 66, $value, $index, 'AdditiveExpression', 'MultiplicativeExpression')) {
  0            
  0            
1309 0 0         if ($index == 0) {
1310             }
1311             }
1312              
1313 0           return $rc;
1314             }
1315              
1316              
1317              
1318             sub G1_67 {
1319 0     0 1   my ($self, $value, $index) = @_;
1320              
1321 0           my $rc = '';
1322              
1323 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 67, $value, $index, 'AdditiveExpression', 'AdditiveExpression', 'PLUS', 'MultiplicativeExpression')) {
  0            
  0            
1324 0 0         if ($index == 0) {
    0          
    0          
1325             }
1326             elsif ($index == 1) {
1327 0           $rc = $self->lexeme('PLUS', 67, $value, 1, 'AdditiveExpression', 'AdditiveExpression', 'PLUS', 'MultiplicativeExpression');
1328             }
1329             elsif ($index == 2) {
1330             }
1331             }
1332              
1333 0           return $rc;
1334             }
1335              
1336              
1337              
1338             sub G1_68 {
1339 0     0 1   my ($self, $value, $index) = @_;
1340              
1341 0           my $rc = '';
1342              
1343 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 68, $value, $index, 'AdditiveExpression', 'AdditiveExpression', 'MINUS', 'MultiplicativeExpression')) {
  0            
  0            
1344 0 0         if ($index == 0) {
    0          
    0          
1345             }
1346             elsif ($index == 1) {
1347 0           $rc = $self->lexeme('MINUS', 68, $value, 1, 'AdditiveExpression', 'AdditiveExpression', 'MINUS', 'MultiplicativeExpression');
1348             }
1349             elsif ($index == 2) {
1350             }
1351             }
1352              
1353 0           return $rc;
1354             }
1355              
1356              
1357              
1358             sub G1_69 {
1359 0     0 1   my ($self, $value, $index) = @_;
1360              
1361 0           my $rc = '';
1362              
1363 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 69, $value, $index, 'ShiftExpression', 'AdditiveExpression')) {
  0            
  0            
1364 0 0         if ($index == 0) {
1365             }
1366             }
1367              
1368 0           return $rc;
1369             }
1370              
1371              
1372              
1373             sub G1_70 {
1374 0     0 1   my ($self, $value, $index) = @_;
1375              
1376 0           my $rc = '';
1377              
1378 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 70, $value, $index, 'ShiftExpression', 'ShiftExpression', 'LEFTMOVE', 'AdditiveExpression')) {
  0            
  0            
1379 0 0         if ($index == 0) {
    0          
    0          
1380             }
1381             elsif ($index == 1) {
1382 0           $rc = $self->lexeme('LEFTMOVE', 70, $value, 1, 'ShiftExpression', 'ShiftExpression', 'LEFTMOVE', 'AdditiveExpression');
1383             }
1384             elsif ($index == 2) {
1385             }
1386             }
1387              
1388 0           return $rc;
1389             }
1390              
1391              
1392              
1393             sub G1_71 {
1394 0     0 1   my ($self, $value, $index) = @_;
1395              
1396 0           my $rc = '';
1397              
1398 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 71, $value, $index, 'ShiftExpression', 'ShiftExpression', 'RIGHTMOVE', 'AdditiveExpression')) {
  0            
  0            
1399 0 0         if ($index == 0) {
    0          
    0          
1400             }
1401             elsif ($index == 1) {
1402 0           $rc = $self->lexeme('RIGHTMOVE', 71, $value, 1, 'ShiftExpression', 'ShiftExpression', 'RIGHTMOVE', 'AdditiveExpression');
1403             }
1404             elsif ($index == 2) {
1405             }
1406             }
1407              
1408 0           return $rc;
1409             }
1410              
1411              
1412              
1413             sub G1_72 {
1414 0     0 1   my ($self, $value, $index) = @_;
1415              
1416 0           my $rc = '';
1417              
1418 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 72, $value, $index, 'ShiftExpression', 'ShiftExpression', 'RIGHTMOVEFILL', 'AdditiveExpression')) {
  0            
  0            
1419 0 0         if ($index == 0) {
    0          
    0          
1420             }
1421             elsif ($index == 1) {
1422 0           $rc = $self->lexeme('RIGHTMOVEFILL', 72, $value, 1, 'ShiftExpression', 'ShiftExpression', 'RIGHTMOVEFILL', 'AdditiveExpression');
1423             }
1424             elsif ($index == 2) {
1425             }
1426             }
1427              
1428 0           return $rc;
1429             }
1430              
1431              
1432              
1433             sub G1_73 {
1434 0     0 1   my ($self, $value, $index) = @_;
1435              
1436 0           my $rc = '';
1437              
1438 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 73, $value, $index, 'RelationalExpression', 'ShiftExpression')) {
  0            
  0            
1439 0 0         if ($index == 0) {
1440             }
1441             }
1442              
1443 0           return $rc;
1444             }
1445              
1446              
1447              
1448             sub G1_74 {
1449 0     0 1   my ($self, $value, $index) = @_;
1450              
1451 0           my $rc = '';
1452              
1453 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 74, $value, $index, 'RelationalExpression', 'RelationalExpression', 'LT', 'ShiftExpression')) {
  0            
  0            
1454 0 0         if ($index == 0) {
    0          
    0          
1455             }
1456             elsif ($index == 1) {
1457 0           $rc = $self->lexeme('LT', 74, $value, 1, 'RelationalExpression', 'RelationalExpression', 'LT', 'ShiftExpression');
1458             }
1459             elsif ($index == 2) {
1460             }
1461             }
1462              
1463 0           return $rc;
1464             }
1465              
1466              
1467              
1468             sub G1_75 {
1469 0     0 1   my ($self, $value, $index) = @_;
1470              
1471 0           my $rc = '';
1472              
1473 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 75, $value, $index, 'RelationalExpression', 'RelationalExpression', 'GT', 'ShiftExpression')) {
  0            
  0            
1474 0 0         if ($index == 0) {
    0          
    0          
1475             }
1476             elsif ($index == 1) {
1477 0           $rc = $self->lexeme('GT', 75, $value, 1, 'RelationalExpression', 'RelationalExpression', 'GT', 'ShiftExpression');
1478             }
1479             elsif ($index == 2) {
1480             }
1481             }
1482              
1483 0           return $rc;
1484             }
1485              
1486              
1487              
1488             sub G1_76 {
1489 0     0 1   my ($self, $value, $index) = @_;
1490              
1491 0           my $rc = '';
1492              
1493 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 76, $value, $index, 'RelationalExpression', 'RelationalExpression', 'LE', 'ShiftExpression')) {
  0            
  0            
1494 0 0         if ($index == 0) {
    0          
    0          
1495             }
1496             elsif ($index == 1) {
1497 0           $rc = $self->lexeme('LE', 76, $value, 1, 'RelationalExpression', 'RelationalExpression', 'LE', 'ShiftExpression');
1498             }
1499             elsif ($index == 2) {
1500             }
1501             }
1502              
1503 0           return $rc;
1504             }
1505              
1506              
1507              
1508             sub G1_77 {
1509 0     0 1   my ($self, $value, $index) = @_;
1510              
1511 0           my $rc = '';
1512              
1513 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 77, $value, $index, 'RelationalExpression', 'RelationalExpression', 'GE', 'ShiftExpression')) {
  0            
  0            
1514 0 0         if ($index == 0) {
    0          
    0          
1515             }
1516             elsif ($index == 1) {
1517 0           $rc = $self->lexeme('GE', 77, $value, 1, 'RelationalExpression', 'RelationalExpression', 'GE', 'ShiftExpression');
1518             }
1519             elsif ($index == 2) {
1520             }
1521             }
1522              
1523 0           return $rc;
1524             }
1525              
1526              
1527              
1528             sub G1_78 {
1529 0     0 1   my ($self, $value, $index) = @_;
1530              
1531 0           my $rc = '';
1532              
1533 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 78, $value, $index, 'RelationalExpression', 'RelationalExpression', 'INSTANCEOF', 'ShiftExpression')) {
  0            
  0            
1534 0 0         if ($index == 0) {
    0          
    0          
1535             }
1536             elsif ($index == 1) {
1537 0           $rc = $self->lexeme('INSTANCEOF', 78, $value, 1, 'RelationalExpression', 'RelationalExpression', 'INSTANCEOF', 'ShiftExpression');
1538             }
1539             elsif ($index == 2) {
1540             }
1541             }
1542              
1543 0           return $rc;
1544             }
1545              
1546              
1547              
1548             sub G1_79 {
1549 0     0 1   my ($self, $value, $index) = @_;
1550              
1551 0           my $rc = '';
1552              
1553 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 79, $value, $index, 'RelationalExpression', 'RelationalExpression', 'IN', 'ShiftExpression')) {
  0            
  0            
1554 0 0         if ($index == 0) {
    0          
    0          
1555             }
1556             elsif ($index == 1) {
1557 0           $rc = $self->lexeme('IN', 79, $value, 1, 'RelationalExpression', 'RelationalExpression', 'IN', 'ShiftExpression');
1558             }
1559             elsif ($index == 2) {
1560             }
1561             }
1562              
1563 0           return $rc;
1564             }
1565              
1566              
1567              
1568             sub G1_80 {
1569 0     0 1   my ($self, $value, $index) = @_;
1570              
1571 0           my $rc = '';
1572              
1573 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 80, $value, $index, 'RelationalExpressionNoIn', 'ShiftExpression')) {
  0            
  0            
1574 0 0         if ($index == 0) {
1575             }
1576             }
1577              
1578 0           return $rc;
1579             }
1580              
1581              
1582              
1583             sub G1_81 {
1584 0     0 1   my ($self, $value, $index) = @_;
1585              
1586 0           my $rc = '';
1587              
1588 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 81, $value, $index, 'RelationalExpressionNoIn', 'RelationalExpressionNoIn', 'LT', 'ShiftExpression')) {
  0            
  0            
1589 0 0         if ($index == 0) {
    0          
    0          
1590             }
1591             elsif ($index == 1) {
1592 0           $rc = $self->lexeme('LT', 81, $value, 1, 'RelationalExpressionNoIn', 'RelationalExpressionNoIn', 'LT', 'ShiftExpression');
1593             }
1594             elsif ($index == 2) {
1595             }
1596             }
1597              
1598 0           return $rc;
1599             }
1600              
1601              
1602              
1603             sub G1_82 {
1604 0     0 1   my ($self, $value, $index) = @_;
1605              
1606 0           my $rc = '';
1607              
1608 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 82, $value, $index, 'RelationalExpressionNoIn', 'RelationalExpressionNoIn', 'GT', 'ShiftExpression')) {
  0            
  0            
1609 0 0         if ($index == 0) {
    0          
    0          
1610             }
1611             elsif ($index == 1) {
1612 0           $rc = $self->lexeme('GT', 82, $value, 1, 'RelationalExpressionNoIn', 'RelationalExpressionNoIn', 'GT', 'ShiftExpression');
1613             }
1614             elsif ($index == 2) {
1615             }
1616             }
1617              
1618 0           return $rc;
1619             }
1620              
1621              
1622              
1623             sub G1_83 {
1624 0     0 1   my ($self, $value, $index) = @_;
1625              
1626 0           my $rc = '';
1627              
1628 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 83, $value, $index, 'RelationalExpressionNoIn', 'RelationalExpressionNoIn', 'LE', 'ShiftExpression')) {
  0            
  0            
1629 0 0         if ($index == 0) {
    0          
    0          
1630             }
1631             elsif ($index == 1) {
1632 0           $rc = $self->lexeme('LE', 83, $value, 1, 'RelationalExpressionNoIn', 'RelationalExpressionNoIn', 'LE', 'ShiftExpression');
1633             }
1634             elsif ($index == 2) {
1635             }
1636             }
1637              
1638 0           return $rc;
1639             }
1640              
1641              
1642              
1643             sub G1_84 {
1644 0     0 1   my ($self, $value, $index) = @_;
1645              
1646 0           my $rc = '';
1647              
1648 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 84, $value, $index, 'RelationalExpressionNoIn', 'RelationalExpressionNoIn', 'GE', 'ShiftExpression')) {
  0            
  0            
1649 0 0         if ($index == 0) {
    0          
    0          
1650             }
1651             elsif ($index == 1) {
1652 0           $rc = $self->lexeme('GE', 84, $value, 1, 'RelationalExpressionNoIn', 'RelationalExpressionNoIn', 'GE', 'ShiftExpression');
1653             }
1654             elsif ($index == 2) {
1655             }
1656             }
1657              
1658 0           return $rc;
1659             }
1660              
1661              
1662              
1663             sub G1_85 {
1664 0     0 1   my ($self, $value, $index) = @_;
1665              
1666 0           my $rc = '';
1667              
1668 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 85, $value, $index, 'RelationalExpressionNoIn', 'RelationalExpressionNoIn', 'INSTANCEOF', 'ShiftExpression')) {
  0            
  0            
1669 0 0         if ($index == 0) {
    0          
    0          
1670             }
1671             elsif ($index == 1) {
1672 0           $rc = $self->lexeme('INSTANCEOF', 85, $value, 1, 'RelationalExpressionNoIn', 'RelationalExpressionNoIn', 'INSTANCEOF', 'ShiftExpression');
1673             }
1674             elsif ($index == 2) {
1675             }
1676             }
1677              
1678 0           return $rc;
1679             }
1680              
1681              
1682              
1683             sub G1_86 {
1684 0     0 1   my ($self, $value, $index) = @_;
1685              
1686 0           my $rc = '';
1687              
1688 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 86, $value, $index, 'EqualityExpression', 'RelationalExpression')) {
  0            
  0            
1689 0 0         if ($index == 0) {
1690             }
1691             }
1692              
1693 0           return $rc;
1694             }
1695              
1696              
1697              
1698             sub G1_87 {
1699 0     0 1   my ($self, $value, $index) = @_;
1700              
1701 0           my $rc = '';
1702              
1703 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 87, $value, $index, 'EqualityExpression', 'EqualityExpression', 'EQ', 'RelationalExpression')) {
  0            
  0            
1704 0 0         if ($index == 0) {
    0          
    0          
1705             }
1706             elsif ($index == 1) {
1707 0           $rc = $self->lexeme('EQ', 87, $value, 1, 'EqualityExpression', 'EqualityExpression', 'EQ', 'RelationalExpression');
1708             }
1709             elsif ($index == 2) {
1710             }
1711             }
1712              
1713 0           return $rc;
1714             }
1715              
1716              
1717              
1718             sub G1_88 {
1719 0     0 1   my ($self, $value, $index) = @_;
1720              
1721 0           my $rc = '';
1722              
1723 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 88, $value, $index, 'EqualityExpression', 'EqualityExpression', 'NE', 'RelationalExpression')) {
  0            
  0            
1724 0 0         if ($index == 0) {
    0          
    0          
1725             }
1726             elsif ($index == 1) {
1727 0           $rc = $self->lexeme('NE', 88, $value, 1, 'EqualityExpression', 'EqualityExpression', 'NE', 'RelationalExpression');
1728             }
1729             elsif ($index == 2) {
1730             }
1731             }
1732              
1733 0           return $rc;
1734             }
1735              
1736              
1737              
1738             sub G1_89 {
1739 0     0 1   my ($self, $value, $index) = @_;
1740              
1741 0           my $rc = '';
1742              
1743 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 89, $value, $index, 'EqualityExpression', 'EqualityExpression', 'STRICTEQ', 'RelationalExpression')) {
  0            
  0            
1744 0 0         if ($index == 0) {
    0          
    0          
1745             }
1746             elsif ($index == 1) {
1747 0           $rc = $self->lexeme('STRICTEQ', 89, $value, 1, 'EqualityExpression', 'EqualityExpression', 'STRICTEQ', 'RelationalExpression');
1748             }
1749             elsif ($index == 2) {
1750             }
1751             }
1752              
1753 0           return $rc;
1754             }
1755              
1756              
1757              
1758             sub G1_90 {
1759 0     0 1   my ($self, $value, $index) = @_;
1760              
1761 0           my $rc = '';
1762              
1763 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 90, $value, $index, 'EqualityExpression', 'EqualityExpression', 'STRICTNE', 'RelationalExpression')) {
  0            
  0            
1764 0 0         if ($index == 0) {
    0          
    0          
1765             }
1766             elsif ($index == 1) {
1767 0           $rc = $self->lexeme('STRICTNE', 90, $value, 1, 'EqualityExpression', 'EqualityExpression', 'STRICTNE', 'RelationalExpression');
1768             }
1769             elsif ($index == 2) {
1770             }
1771             }
1772              
1773 0           return $rc;
1774             }
1775              
1776              
1777              
1778             sub G1_91 {
1779 0     0 1   my ($self, $value, $index) = @_;
1780              
1781 0           my $rc = '';
1782              
1783 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 91, $value, $index, 'EqualityExpressionNoIn', 'RelationalExpressionNoIn')) {
  0            
  0            
1784 0 0         if ($index == 0) {
1785             }
1786             }
1787              
1788 0           return $rc;
1789             }
1790              
1791              
1792              
1793             sub G1_92 {
1794 0     0 1   my ($self, $value, $index) = @_;
1795              
1796 0           my $rc = '';
1797              
1798 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 92, $value, $index, 'EqualityExpressionNoIn', 'EqualityExpressionNoIn', 'EQ', 'RelationalExpressionNoIn')) {
  0            
  0            
1799 0 0         if ($index == 0) {
    0          
    0          
1800             }
1801             elsif ($index == 1) {
1802 0           $rc = $self->lexeme('EQ', 92, $value, 1, 'EqualityExpressionNoIn', 'EqualityExpressionNoIn', 'EQ', 'RelationalExpressionNoIn');
1803             }
1804             elsif ($index == 2) {
1805             }
1806             }
1807              
1808 0           return $rc;
1809             }
1810              
1811              
1812              
1813             sub G1_93 {
1814 0     0 1   my ($self, $value, $index) = @_;
1815              
1816 0           my $rc = '';
1817              
1818 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 93, $value, $index, 'EqualityExpressionNoIn', 'EqualityExpressionNoIn', 'NE', 'RelationalExpressionNoIn')) {
  0            
  0            
1819 0 0         if ($index == 0) {
    0          
    0          
1820             }
1821             elsif ($index == 1) {
1822 0           $rc = $self->lexeme('NE', 93, $value, 1, 'EqualityExpressionNoIn', 'EqualityExpressionNoIn', 'NE', 'RelationalExpressionNoIn');
1823             }
1824             elsif ($index == 2) {
1825             }
1826             }
1827              
1828 0           return $rc;
1829             }
1830              
1831              
1832              
1833             sub G1_94 {
1834 0     0 1   my ($self, $value, $index) = @_;
1835              
1836 0           my $rc = '';
1837              
1838 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 94, $value, $index, 'EqualityExpressionNoIn', 'EqualityExpressionNoIn', 'STRICTEQ', 'RelationalExpressionNoIn')) {
  0            
  0            
1839 0 0         if ($index == 0) {
    0          
    0          
1840             }
1841             elsif ($index == 1) {
1842 0           $rc = $self->lexeme('STRICTEQ', 94, $value, 1, 'EqualityExpressionNoIn', 'EqualityExpressionNoIn', 'STRICTEQ', 'RelationalExpressionNoIn');
1843             }
1844             elsif ($index == 2) {
1845             }
1846             }
1847              
1848 0           return $rc;
1849             }
1850              
1851              
1852              
1853             sub G1_95 {
1854 0     0 1   my ($self, $value, $index) = @_;
1855              
1856 0           my $rc = '';
1857              
1858 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 95, $value, $index, 'EqualityExpressionNoIn', 'EqualityExpressionNoIn', 'STRICTNE', 'RelationalExpressionNoIn')) {
  0            
  0            
1859 0 0         if ($index == 0) {
    0          
    0          
1860             }
1861             elsif ($index == 1) {
1862 0           $rc = $self->lexeme('STRICTNE', 95, $value, 1, 'EqualityExpressionNoIn', 'EqualityExpressionNoIn', 'STRICTNE', 'RelationalExpressionNoIn');
1863             }
1864             elsif ($index == 2) {
1865             }
1866             }
1867              
1868 0           return $rc;
1869             }
1870              
1871              
1872              
1873             sub G1_96 {
1874 0     0 1   my ($self, $value, $index) = @_;
1875              
1876 0           my $rc = '';
1877              
1878 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 96, $value, $index, 'BitwiseANDExpression', 'EqualityExpression')) {
  0            
  0            
1879 0 0         if ($index == 0) {
1880             }
1881             }
1882              
1883 0           return $rc;
1884             }
1885              
1886              
1887              
1888             sub G1_97 {
1889 0     0 1   my ($self, $value, $index) = @_;
1890              
1891 0           my $rc = '';
1892              
1893 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 97, $value, $index, 'BitwiseANDExpression', 'BitwiseANDExpression', 'BITAND', 'EqualityExpression')) {
  0            
  0            
1894 0 0         if ($index == 0) {
    0          
    0          
1895             }
1896             elsif ($index == 1) {
1897 0           $rc = $self->lexeme('BITAND', 97, $value, 1, 'BitwiseANDExpression', 'BitwiseANDExpression', 'BITAND', 'EqualityExpression');
1898             }
1899             elsif ($index == 2) {
1900             }
1901             }
1902              
1903 0           return $rc;
1904             }
1905              
1906              
1907              
1908             sub G1_98 {
1909 0     0 1   my ($self, $value, $index) = @_;
1910              
1911 0           my $rc = '';
1912              
1913 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 98, $value, $index, 'BitwiseANDExpressionNoIn', 'EqualityExpressionNoIn')) {
  0            
  0            
1914 0 0         if ($index == 0) {
1915             }
1916             }
1917              
1918 0           return $rc;
1919             }
1920              
1921              
1922              
1923             sub G1_99 {
1924 0     0 1   my ($self, $value, $index) = @_;
1925              
1926 0           my $rc = '';
1927              
1928 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 99, $value, $index, 'BitwiseANDExpressionNoIn', 'BitwiseANDExpressionNoIn', 'BITAND', 'EqualityExpressionNoIn')) {
  0            
  0            
1929 0 0         if ($index == 0) {
    0          
    0          
1930             }
1931             elsif ($index == 1) {
1932 0           $rc = $self->lexeme('BITAND', 99, $value, 1, 'BitwiseANDExpressionNoIn', 'BitwiseANDExpressionNoIn', 'BITAND', 'EqualityExpressionNoIn');
1933             }
1934             elsif ($index == 2) {
1935             }
1936             }
1937              
1938 0           return $rc;
1939             }
1940              
1941              
1942              
1943             sub G1_100 {
1944 0     0 1   my ($self, $value, $index) = @_;
1945              
1946 0           my $rc = '';
1947              
1948 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 100, $value, $index, 'BitwiseXORExpression', 'BitwiseANDExpression')) {
  0            
  0            
1949 0 0         if ($index == 0) {
1950             }
1951             }
1952              
1953 0           return $rc;
1954             }
1955              
1956              
1957              
1958             sub G1_101 {
1959 0     0 1   my ($self, $value, $index) = @_;
1960              
1961 0           my $rc = '';
1962              
1963 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 101, $value, $index, 'BitwiseXORExpression', 'BitwiseXORExpression', 'BITXOR', 'BitwiseANDExpression')) {
  0            
  0            
1964 0 0         if ($index == 0) {
    0          
    0          
1965             }
1966             elsif ($index == 1) {
1967 0           $rc = $self->lexeme('BITXOR', 101, $value, 1, 'BitwiseXORExpression', 'BitwiseXORExpression', 'BITXOR', 'BitwiseANDExpression');
1968             }
1969             elsif ($index == 2) {
1970             }
1971             }
1972              
1973 0           return $rc;
1974             }
1975              
1976              
1977              
1978             sub G1_102 {
1979 0     0 1   my ($self, $value, $index) = @_;
1980              
1981 0           my $rc = '';
1982              
1983 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 102, $value, $index, 'BitwiseXORExpressionNoIn', 'BitwiseANDExpressionNoIn')) {
  0            
  0            
1984 0 0         if ($index == 0) {
1985             }
1986             }
1987              
1988 0           return $rc;
1989             }
1990              
1991              
1992              
1993             sub G1_103 {
1994 0     0 1   my ($self, $value, $index) = @_;
1995              
1996 0           my $rc = '';
1997              
1998 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 103, $value, $index, 'BitwiseXORExpressionNoIn', 'BitwiseXORExpressionNoIn', 'BITXOR', 'BitwiseANDExpressionNoIn')) {
  0            
  0            
1999 0 0         if ($index == 0) {
    0          
    0          
2000             }
2001             elsif ($index == 1) {
2002 0           $rc = $self->lexeme('BITXOR', 103, $value, 1, 'BitwiseXORExpressionNoIn', 'BitwiseXORExpressionNoIn', 'BITXOR', 'BitwiseANDExpressionNoIn');
2003             }
2004             elsif ($index == 2) {
2005             }
2006             }
2007              
2008 0           return $rc;
2009             }
2010              
2011              
2012              
2013             sub G1_104 {
2014 0     0 1   my ($self, $value, $index) = @_;
2015              
2016 0           my $rc = '';
2017              
2018 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 104, $value, $index, 'BitwiseORExpression', 'BitwiseXORExpression')) {
  0            
  0            
2019 0 0         if ($index == 0) {
2020             }
2021             }
2022              
2023 0           return $rc;
2024             }
2025              
2026              
2027              
2028             sub G1_105 {
2029 0     0 1   my ($self, $value, $index) = @_;
2030              
2031 0           my $rc = '';
2032              
2033 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 105, $value, $index, 'BitwiseORExpression', 'BitwiseORExpression', 'BITOR', 'BitwiseXORExpression')) {
  0            
  0            
2034 0 0         if ($index == 0) {
    0          
    0          
2035             }
2036             elsif ($index == 1) {
2037 0           $rc = $self->lexeme('BITOR', 105, $value, 1, 'BitwiseORExpression', 'BitwiseORExpression', 'BITOR', 'BitwiseXORExpression');
2038             }
2039             elsif ($index == 2) {
2040             }
2041             }
2042              
2043 0           return $rc;
2044             }
2045              
2046              
2047              
2048             sub G1_106 {
2049 0     0 1   my ($self, $value, $index) = @_;
2050              
2051 0           my $rc = '';
2052              
2053 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 106, $value, $index, 'BitwiseORExpressionNoIn', 'BitwiseXORExpressionNoIn')) {
  0            
  0            
2054 0 0         if ($index == 0) {
2055             }
2056             }
2057              
2058 0           return $rc;
2059             }
2060              
2061              
2062              
2063             sub G1_107 {
2064 0     0 1   my ($self, $value, $index) = @_;
2065              
2066 0           my $rc = '';
2067              
2068 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 107, $value, $index, 'BitwiseORExpressionNoIn', 'BitwiseORExpressionNoIn', 'BITOR', 'BitwiseXORExpressionNoIn')) {
  0            
  0            
2069 0 0         if ($index == 0) {
    0          
    0          
2070             }
2071             elsif ($index == 1) {
2072 0           $rc = $self->lexeme('BITOR', 107, $value, 1, 'BitwiseORExpressionNoIn', 'BitwiseORExpressionNoIn', 'BITOR', 'BitwiseXORExpressionNoIn');
2073             }
2074             elsif ($index == 2) {
2075             }
2076             }
2077              
2078 0           return $rc;
2079             }
2080              
2081              
2082              
2083             sub G1_108 {
2084 0     0 1   my ($self, $value, $index) = @_;
2085              
2086 0           my $rc = '';
2087              
2088 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 108, $value, $index, 'LogicalANDExpression', 'BitwiseORExpression')) {
  0            
  0            
2089 0 0         if ($index == 0) {
2090             }
2091             }
2092              
2093 0           return $rc;
2094             }
2095              
2096              
2097              
2098             sub G1_109 {
2099 0     0 1   my ($self, $value, $index) = @_;
2100              
2101 0           my $rc = '';
2102              
2103 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 109, $value, $index, 'LogicalANDExpression', 'LogicalANDExpression', 'AND', 'BitwiseORExpression')) {
  0            
  0            
2104 0 0         if ($index == 0) {
    0          
    0          
2105             }
2106             elsif ($index == 1) {
2107 0           $rc = $self->lexeme('AND', 109, $value, 1, 'LogicalANDExpression', 'LogicalANDExpression', 'AND', 'BitwiseORExpression');
2108             }
2109             elsif ($index == 2) {
2110             }
2111             }
2112              
2113 0           return $rc;
2114             }
2115              
2116              
2117              
2118             sub G1_110 {
2119 0     0 1   my ($self, $value, $index) = @_;
2120              
2121 0           my $rc = '';
2122              
2123 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 110, $value, $index, 'LogicalANDExpressionNoIn', 'BitwiseORExpressionNoIn')) {
  0            
  0            
2124 0 0         if ($index == 0) {
2125             }
2126             }
2127              
2128 0           return $rc;
2129             }
2130              
2131              
2132              
2133             sub G1_111 {
2134 0     0 1   my ($self, $value, $index) = @_;
2135              
2136 0           my $rc = '';
2137              
2138 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 111, $value, $index, 'LogicalANDExpressionNoIn', 'LogicalANDExpressionNoIn', 'AND', 'BitwiseORExpressionNoIn')) {
  0            
  0            
2139 0 0         if ($index == 0) {
    0          
    0          
2140             }
2141             elsif ($index == 1) {
2142 0           $rc = $self->lexeme('AND', 111, $value, 1, 'LogicalANDExpressionNoIn', 'LogicalANDExpressionNoIn', 'AND', 'BitwiseORExpressionNoIn');
2143             }
2144             elsif ($index == 2) {
2145             }
2146             }
2147              
2148 0           return $rc;
2149             }
2150              
2151              
2152              
2153             sub G1_112 {
2154 0     0 1   my ($self, $value, $index) = @_;
2155              
2156 0           my $rc = '';
2157              
2158 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 112, $value, $index, 'LogicalORExpression', 'LogicalANDExpression')) {
  0            
  0            
2159 0 0         if ($index == 0) {
2160             }
2161             }
2162              
2163 0           return $rc;
2164             }
2165              
2166              
2167              
2168             sub G1_113 {
2169 0     0 1   my ($self, $value, $index) = @_;
2170              
2171 0           my $rc = '';
2172              
2173 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 113, $value, $index, 'LogicalORExpression', 'LogicalORExpression', 'OR', 'LogicalANDExpression')) {
  0            
  0            
2174 0 0         if ($index == 0) {
    0          
    0          
2175             }
2176             elsif ($index == 1) {
2177 0           $rc = $self->lexeme('OR', 113, $value, 1, 'LogicalORExpression', 'LogicalORExpression', 'OR', 'LogicalANDExpression');
2178             }
2179             elsif ($index == 2) {
2180             }
2181             }
2182              
2183 0           return $rc;
2184             }
2185              
2186              
2187              
2188             sub G1_114 {
2189 0     0 1   my ($self, $value, $index) = @_;
2190              
2191 0           my $rc = '';
2192              
2193 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 114, $value, $index, 'LogicalORExpressionNoIn', 'LogicalANDExpressionNoIn')) {
  0            
  0            
2194 0 0         if ($index == 0) {
2195             }
2196             }
2197              
2198 0           return $rc;
2199             }
2200              
2201              
2202              
2203             sub G1_115 {
2204 0     0 1   my ($self, $value, $index) = @_;
2205              
2206 0           my $rc = '';
2207              
2208 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 115, $value, $index, 'LogicalORExpressionNoIn', 'LogicalORExpressionNoIn', 'OR', 'LogicalANDExpressionNoIn')) {
  0            
  0            
2209 0 0         if ($index == 0) {
    0          
    0          
2210             }
2211             elsif ($index == 1) {
2212 0           $rc = $self->lexeme('OR', 115, $value, 1, 'LogicalORExpressionNoIn', 'LogicalORExpressionNoIn', 'OR', 'LogicalANDExpressionNoIn');
2213             }
2214             elsif ($index == 2) {
2215             }
2216             }
2217              
2218 0           return $rc;
2219             }
2220              
2221              
2222              
2223             sub G1_116 {
2224 0     0 1   my ($self, $value, $index) = @_;
2225              
2226 0           my $rc = '';
2227              
2228 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 116, $value, $index, 'ConditionalExpression', 'LogicalORExpression')) {
  0            
  0            
2229 0 0         if ($index == 0) {
2230             }
2231             }
2232              
2233 0           return $rc;
2234             }
2235              
2236              
2237              
2238             sub G1_117 {
2239 0     0 1   my ($self, $value, $index) = @_;
2240              
2241 0           my $rc = '';
2242              
2243 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 117, $value, $index, 'ConditionalExpression', 'LogicalORExpression', 'QUESTION_MARK', 'AssignmentExpression', 'COLON', 'AssignmentExpression')) {
  0            
  0            
2244 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
2245             }
2246             elsif ($index == 1) {
2247 0           $rc = $self->lexeme('QUESTION_MARK', 117, $value, 1, 'ConditionalExpression', 'LogicalORExpression', 'QUESTION_MARK', 'AssignmentExpression', 'COLON', 'AssignmentExpression');
2248             }
2249             elsif ($index == 2) {
2250             }
2251             elsif ($index == 3) {
2252 0           $rc = $self->lexeme('COLON', 117, $value, 3, 'ConditionalExpression', 'LogicalORExpression', 'QUESTION_MARK', 'AssignmentExpression', 'COLON', 'AssignmentExpression');
2253             }
2254             elsif ($index == 4) {
2255             }
2256             }
2257              
2258 0           return $rc;
2259             }
2260              
2261              
2262              
2263             sub G1_118 {
2264 0     0 1   my ($self, $value, $index) = @_;
2265              
2266 0           my $rc = '';
2267              
2268 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 118, $value, $index, 'ConditionalExpressionNoIn', 'LogicalORExpressionNoIn')) {
  0            
  0            
2269 0 0         if ($index == 0) {
2270             }
2271             }
2272              
2273 0           return $rc;
2274             }
2275              
2276              
2277              
2278             sub G1_119 {
2279 0     0 1   my ($self, $value, $index) = @_;
2280              
2281 0           my $rc = '';
2282              
2283 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 119, $value, $index, 'ConditionalExpressionNoIn', 'LogicalORExpressionNoIn', 'QUESTION_MARK', 'AssignmentExpression', 'COLON', 'AssignmentExpressionNoIn')) {
  0            
  0            
2284 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
2285             }
2286             elsif ($index == 1) {
2287 0           $rc = $self->lexeme('QUESTION_MARK', 119, $value, 1, 'ConditionalExpressionNoIn', 'LogicalORExpressionNoIn', 'QUESTION_MARK', 'AssignmentExpression', 'COLON', 'AssignmentExpressionNoIn');
2288             }
2289             elsif ($index == 2) {
2290             }
2291             elsif ($index == 3) {
2292 0           $rc = $self->lexeme('COLON', 119, $value, 3, 'ConditionalExpressionNoIn', 'LogicalORExpressionNoIn', 'QUESTION_MARK', 'AssignmentExpression', 'COLON', 'AssignmentExpressionNoIn');
2293             }
2294             elsif ($index == 4) {
2295             }
2296             }
2297              
2298 0           return $rc;
2299             }
2300              
2301              
2302              
2303             sub G1_120 {
2304 0     0 1   my ($self, $value, $index) = @_;
2305              
2306 0           my $rc = '';
2307              
2308 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 120, $value, $index, 'AssignmentExpression', 'ConditionalExpression')) {
  0            
  0            
2309 0 0         if ($index == 0) {
2310             }
2311             }
2312              
2313 0           return $rc;
2314             }
2315              
2316              
2317              
2318             sub G1_121 {
2319 0     0 1   my ($self, $value, $index) = @_;
2320              
2321 0           my $rc = '';
2322              
2323 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 121, $value, $index, 'AssignmentExpression', 'LeftHandSideExpression', 'ASSIGN', 'AssignmentExpression')) {
  0            
  0            
2324 0 0         if ($index == 0) {
    0          
    0          
2325             }
2326             elsif ($index == 1) {
2327 0           $rc = $self->lexeme('ASSIGN', 121, $value, 1, 'AssignmentExpression', 'LeftHandSideExpression', 'ASSIGN', 'AssignmentExpression');
2328             }
2329             elsif ($index == 2) {
2330             }
2331             }
2332              
2333 0           return $rc;
2334             }
2335              
2336              
2337              
2338             sub G1_122 {
2339 0     0 1   my ($self, $value, $index) = @_;
2340              
2341 0           my $rc = '';
2342              
2343 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 122, $value, $index, 'AssignmentExpression', 'LeftHandSideExpression', 'AssignmentOperator', 'AssignmentExpression')) {
  0            
  0            
2344 0 0         if ($index == 0) {
    0          
    0          
2345             }
2346             elsif ($index == 1) {
2347             }
2348             elsif ($index == 2) {
2349             }
2350             }
2351              
2352 0           return $rc;
2353             }
2354              
2355              
2356              
2357             sub G1_123 {
2358 0     0 1   my ($self, $value, $index) = @_;
2359              
2360 0           my $rc = '';
2361              
2362 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 123, $value, $index, 'AssignmentExpressionNoIn', 'ConditionalExpressionNoIn')) {
  0            
  0            
2363 0 0         if ($index == 0) {
2364             }
2365             }
2366              
2367 0           return $rc;
2368             }
2369              
2370              
2371              
2372             sub G1_124 {
2373 0     0 1   my ($self, $value, $index) = @_;
2374              
2375 0           my $rc = '';
2376              
2377 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 124, $value, $index, 'AssignmentExpressionNoIn', 'LeftHandSideExpression', 'ASSIGN', 'AssignmentExpressionNoIn')) {
  0            
  0            
2378 0 0         if ($index == 0) {
    0          
    0          
2379             }
2380             elsif ($index == 1) {
2381 0           $rc = $self->lexeme('ASSIGN', 124, $value, 1, 'AssignmentExpressionNoIn', 'LeftHandSideExpression', 'ASSIGN', 'AssignmentExpressionNoIn');
2382             }
2383             elsif ($index == 2) {
2384             }
2385             }
2386              
2387 0           return $rc;
2388             }
2389              
2390              
2391              
2392             sub G1_125 {
2393 0     0 1   my ($self, $value, $index) = @_;
2394              
2395 0           my $rc = '';
2396              
2397 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 125, $value, $index, 'AssignmentExpressionNoIn', 'LeftHandSideExpression', 'AssignmentOperator', 'AssignmentExpressionNoIn')) {
  0            
  0            
2398 0 0         if ($index == 0) {
    0          
    0          
2399             }
2400             elsif ($index == 1) {
2401             }
2402             elsif ($index == 2) {
2403             }
2404             }
2405              
2406 0           return $rc;
2407             }
2408              
2409              
2410              
2411             sub G1_126 {
2412 0     0 1   my ($self, $value, $index) = @_;
2413              
2414 0           my $rc = '';
2415              
2416 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 126, $value, $index, 'AssignmentOperator', 'MULASSIGN')) {
  0            
  0            
2417 0 0         if ($index == 0) {
2418 0           $rc = $self->lexeme('MULASSIGN', 126, $value, 0, 'AssignmentOperator', 'MULASSIGN');
2419             }
2420             }
2421              
2422 0           return $rc;
2423             }
2424              
2425              
2426              
2427             sub G1_127 {
2428 0     0 1   my ($self, $value, $index) = @_;
2429              
2430 0           my $rc = '';
2431              
2432 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 127, $value, $index, 'AssignmentOperator', 'DIVASSIGN')) {
  0            
  0            
2433 0 0         if ($index == 0) {
2434 0           $rc = $self->lexeme('DIVASSIGN', 127, $value, 0, 'AssignmentOperator', 'DIVASSIGN');
2435             }
2436             }
2437              
2438 0           return $rc;
2439             }
2440              
2441              
2442              
2443             sub G1_128 {
2444 0     0 1   my ($self, $value, $index) = @_;
2445              
2446 0           my $rc = '';
2447              
2448 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 128, $value, $index, 'AssignmentOperator', 'MODULUSASSIGN')) {
  0            
  0            
2449 0 0         if ($index == 0) {
2450 0           $rc = $self->lexeme('MODULUSASSIGN', 128, $value, 0, 'AssignmentOperator', 'MODULUSASSIGN');
2451             }
2452             }
2453              
2454 0           return $rc;
2455             }
2456              
2457              
2458              
2459             sub G1_129 {
2460 0     0 1   my ($self, $value, $index) = @_;
2461              
2462 0           my $rc = '';
2463              
2464 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 129, $value, $index, 'AssignmentOperator', 'PLUSASSIGN')) {
  0            
  0            
2465 0 0         if ($index == 0) {
2466 0           $rc = $self->lexeme('PLUSASSIGN', 129, $value, 0, 'AssignmentOperator', 'PLUSASSIGN');
2467             }
2468             }
2469              
2470 0           return $rc;
2471             }
2472              
2473              
2474              
2475             sub G1_130 {
2476 0     0 1   my ($self, $value, $index) = @_;
2477              
2478 0           my $rc = '';
2479              
2480 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 130, $value, $index, 'AssignmentOperator', 'MINUSASSIGN')) {
  0            
  0            
2481 0 0         if ($index == 0) {
2482 0           $rc = $self->lexeme('MINUSASSIGN', 130, $value, 0, 'AssignmentOperator', 'MINUSASSIGN');
2483             }
2484             }
2485              
2486 0           return $rc;
2487             }
2488              
2489              
2490              
2491             sub G1_131 {
2492 0     0 1   my ($self, $value, $index) = @_;
2493              
2494 0           my $rc = '';
2495              
2496 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 131, $value, $index, 'AssignmentOperator', 'LEFTMOVEASSIGN')) {
  0            
  0            
2497 0 0         if ($index == 0) {
2498 0           $rc = $self->lexeme('LEFTMOVEASSIGN', 131, $value, 0, 'AssignmentOperator', 'LEFTMOVEASSIGN');
2499             }
2500             }
2501              
2502 0           return $rc;
2503             }
2504              
2505              
2506              
2507             sub G1_132 {
2508 0     0 1   my ($self, $value, $index) = @_;
2509              
2510 0           my $rc = '';
2511              
2512 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 132, $value, $index, 'AssignmentOperator', 'RIGHTMOVEASSIGN')) {
  0            
  0            
2513 0 0         if ($index == 0) {
2514 0           $rc = $self->lexeme('RIGHTMOVEASSIGN', 132, $value, 0, 'AssignmentOperator', 'RIGHTMOVEASSIGN');
2515             }
2516             }
2517              
2518 0           return $rc;
2519             }
2520              
2521              
2522              
2523             sub G1_133 {
2524 0     0 1   my ($self, $value, $index) = @_;
2525              
2526 0           my $rc = '';
2527              
2528 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 133, $value, $index, 'AssignmentOperator', 'RIGHTMOVEFILLASSIGN')) {
  0            
  0            
2529 0 0         if ($index == 0) {
2530 0           $rc = $self->lexeme('RIGHTMOVEFILLASSIGN', 133, $value, 0, 'AssignmentOperator', 'RIGHTMOVEFILLASSIGN');
2531             }
2532             }
2533              
2534 0           return $rc;
2535             }
2536              
2537              
2538              
2539             sub G1_134 {
2540 0     0 1   my ($self, $value, $index) = @_;
2541              
2542 0           my $rc = '';
2543              
2544 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 134, $value, $index, 'AssignmentOperator', 'BITANDASSIGN')) {
  0            
  0            
2545 0 0         if ($index == 0) {
2546 0           $rc = $self->lexeme('BITANDASSIGN', 134, $value, 0, 'AssignmentOperator', 'BITANDASSIGN');
2547             }
2548             }
2549              
2550 0           return $rc;
2551             }
2552              
2553              
2554              
2555             sub G1_135 {
2556 0     0 1   my ($self, $value, $index) = @_;
2557              
2558 0           my $rc = '';
2559              
2560 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 135, $value, $index, 'AssignmentOperator', 'BITXORASSIGN')) {
  0            
  0            
2561 0 0         if ($index == 0) {
2562 0           $rc = $self->lexeme('BITXORASSIGN', 135, $value, 0, 'AssignmentOperator', 'BITXORASSIGN');
2563             }
2564             }
2565              
2566 0           return $rc;
2567             }
2568              
2569              
2570              
2571             sub G1_136 {
2572 0     0 1   my ($self, $value, $index) = @_;
2573              
2574 0           my $rc = '';
2575              
2576 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 136, $value, $index, 'AssignmentOperator', 'BITORASSIGN')) {
  0            
  0            
2577 0 0         if ($index == 0) {
2578 0           $rc = $self->lexeme('BITORASSIGN', 136, $value, 0, 'AssignmentOperator', 'BITORASSIGN');
2579             }
2580             }
2581              
2582 0           return $rc;
2583             }
2584              
2585              
2586              
2587             sub G1_137 {
2588 0     0 1   my ($self, $value, $index) = @_;
2589              
2590 0           my $rc = '';
2591              
2592 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 137, $value, $index, 'Expression', 'AssignmentExpression')) {
  0            
  0            
2593 0 0         if ($index == 0) {
2594             }
2595             }
2596              
2597 0           return $rc;
2598             }
2599              
2600              
2601              
2602             sub G1_138 {
2603 0     0 1   my ($self, $value, $index) = @_;
2604              
2605 0           my $rc = '';
2606              
2607 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 138, $value, $index, 'Expression', 'Expression', 'COMMA', 'AssignmentExpression')) {
  0            
  0            
2608 0 0         if ($index == 0) {
    0          
    0          
2609             }
2610             elsif ($index == 1) {
2611 0           $rc = $self->lexeme('COMMA', 138, $value, 1, 'Expression', 'Expression', 'COMMA', 'AssignmentExpression');
2612             }
2613             elsif ($index == 2) {
2614             }
2615             }
2616              
2617 0           return $rc;
2618             }
2619              
2620              
2621              
2622             sub G1_139 {
2623 0     0 1   my ($self, $value, $index) = @_;
2624              
2625 0           my $rc = '';
2626              
2627 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 139, $value, $index, 'ExpressionNoIn', 'AssignmentExpressionNoIn')) {
  0            
  0            
2628 0 0         if ($index == 0) {
2629             }
2630             }
2631              
2632 0           return $rc;
2633             }
2634              
2635              
2636              
2637             sub G1_140 {
2638 0     0 1   my ($self, $value, $index) = @_;
2639              
2640 0           my $rc = '';
2641              
2642 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 140, $value, $index, 'ExpressionNoIn', 'ExpressionNoIn', 'COMMA', 'AssignmentExpressionNoIn')) {
  0            
  0            
2643 0 0         if ($index == 0) {
    0          
    0          
2644             }
2645             elsif ($index == 1) {
2646 0           $rc = $self->lexeme('COMMA', 140, $value, 1, 'ExpressionNoIn', 'ExpressionNoIn', 'COMMA', 'AssignmentExpressionNoIn');
2647             }
2648             elsif ($index == 2) {
2649             }
2650             }
2651              
2652 0           return $rc;
2653             }
2654              
2655              
2656              
2657             sub G1_141 {
2658 0     0 1   my ($self, $value, $index) = @_;
2659              
2660 0           my $rc = '';
2661              
2662 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 141, $value, $index, 'Statement', 'Block')) {
  0            
  0            
2663 0 0         if ($index == 0) {
2664             }
2665             }
2666              
2667 0           return $rc;
2668             }
2669              
2670              
2671              
2672             sub G1_142 {
2673 0     0 1   my ($self, $value, $index) = @_;
2674              
2675 0           my $rc = '';
2676              
2677 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 142, $value, $index, 'Statement', 'VariableStatement')) {
  0            
  0            
2678 0 0         if ($index == 0) {
2679             }
2680             }
2681              
2682 0           return $rc;
2683             }
2684              
2685              
2686              
2687             sub G1_143 {
2688 0     0 1   my ($self, $value, $index) = @_;
2689              
2690 0           my $rc = '';
2691              
2692 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 143, $value, $index, 'Statement', 'EmptyStatement')) {
  0            
  0            
2693 0 0         if ($index == 0) {
2694             }
2695             }
2696              
2697 0           return $rc;
2698             }
2699              
2700              
2701              
2702             sub G1_144 {
2703 0     0 1   my ($self, $value, $index) = @_;
2704              
2705 0           my $rc = '';
2706              
2707 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 144, $value, $index, 'Statement', 'ExpressionStatement')) {
  0            
  0            
2708 0 0         if ($index == 0) {
2709             }
2710             }
2711              
2712 0           return $rc;
2713             }
2714              
2715              
2716              
2717             sub G1_145 {
2718 0     0 1   my ($self, $value, $index) = @_;
2719              
2720 0           my $rc = '';
2721              
2722 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 145, $value, $index, 'Statement', 'IfStatement')) {
  0            
  0            
2723 0 0         if ($index == 0) {
2724             }
2725             }
2726              
2727 0           return $rc;
2728             }
2729              
2730              
2731              
2732             sub G1_146 {
2733 0     0 1   my ($self, $value, $index) = @_;
2734              
2735 0           my $rc = '';
2736              
2737 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 146, $value, $index, 'Statement', 'IterationStatement')) {
  0            
  0            
2738 0 0         if ($index == 0) {
2739             }
2740             }
2741              
2742 0           return $rc;
2743             }
2744              
2745              
2746              
2747             sub G1_147 {
2748 0     0 1   my ($self, $value, $index) = @_;
2749              
2750 0           my $rc = '';
2751              
2752 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 147, $value, $index, 'Statement', 'ContinueStatement')) {
  0            
  0            
2753 0 0         if ($index == 0) {
2754             }
2755             }
2756              
2757 0           return $rc;
2758             }
2759              
2760              
2761              
2762             sub G1_148 {
2763 0     0 1   my ($self, $value, $index) = @_;
2764              
2765 0           my $rc = '';
2766              
2767 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 148, $value, $index, 'Statement', 'BreakStatement')) {
  0            
  0            
2768 0 0         if ($index == 0) {
2769             }
2770             }
2771              
2772 0           return $rc;
2773             }
2774              
2775              
2776              
2777             sub G1_149 {
2778 0     0 1   my ($self, $value, $index) = @_;
2779              
2780 0           my $rc = '';
2781              
2782 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 149, $value, $index, 'Statement', 'ReturnStatement')) {
  0            
  0            
2783 0 0         if ($index == 0) {
2784             }
2785             }
2786              
2787 0           return $rc;
2788             }
2789              
2790              
2791              
2792             sub G1_150 {
2793 0     0 1   my ($self, $value, $index) = @_;
2794              
2795 0           my $rc = '';
2796              
2797 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 150, $value, $index, 'Statement', 'WithStatement')) {
  0            
  0            
2798 0 0         if ($index == 0) {
2799             }
2800             }
2801              
2802 0           return $rc;
2803             }
2804              
2805              
2806              
2807             sub G1_151 {
2808 0     0 1   my ($self, $value, $index) = @_;
2809              
2810 0           my $rc = '';
2811              
2812 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 151, $value, $index, 'Statement', 'LabelledStatement')) {
  0            
  0            
2813 0 0         if ($index == 0) {
2814             }
2815             }
2816              
2817 0           return $rc;
2818             }
2819              
2820              
2821              
2822             sub G1_152 {
2823 0     0 1   my ($self, $value, $index) = @_;
2824              
2825 0           my $rc = '';
2826              
2827 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 152, $value, $index, 'Statement', 'SwitchStatement')) {
  0            
  0            
2828 0 0         if ($index == 0) {
2829             }
2830             }
2831              
2832 0           return $rc;
2833             }
2834              
2835              
2836              
2837             sub G1_153 {
2838 0     0 1   my ($self, $value, $index) = @_;
2839              
2840 0           my $rc = '';
2841              
2842 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 153, $value, $index, 'Statement', 'ThrowStatement')) {
  0            
  0            
2843 0 0         if ($index == 0) {
2844             }
2845             }
2846              
2847 0           return $rc;
2848             }
2849              
2850              
2851              
2852             sub G1_154 {
2853 0     0 1   my ($self, $value, $index) = @_;
2854              
2855 0           my $rc = '';
2856              
2857 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 154, $value, $index, 'Statement', 'TryStatement')) {
  0            
  0            
2858 0 0         if ($index == 0) {
2859             }
2860             }
2861              
2862 0           return $rc;
2863             }
2864              
2865              
2866              
2867             sub G1_155 {
2868 0     0 1   my ($self, $value, $index) = @_;
2869              
2870 0           my $rc = '';
2871              
2872 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 155, $value, $index, 'Statement', 'DebuggerStatement')) {
  0            
  0            
2873 0 0         if ($index == 0) {
2874             }
2875             }
2876              
2877 0           return $rc;
2878             }
2879              
2880              
2881              
2882             sub G1_156 {
2883 0     0 1   my ($self, $value, $index) = @_;
2884              
2885 0           my $rc = '';
2886              
2887 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 156, $value, $index, 'Block', 'LCURLY_BLOCK', 'StatementListopt', 'RCURLY')) {
  0            
  0            
2888 0 0         if ($index == 0) {
    0          
    0          
2889 0           $rc = $self->lexeme('LCURLY_BLOCK', 156, $value, 0, 'Block', 'LCURLY_BLOCK', 'StatementListopt', 'RCURLY');
2890             }
2891             elsif ($index == 1) {
2892             }
2893             elsif ($index == 2) {
2894 0           $rc = $self->lexeme('RCURLY', 156, $value, 2, 'Block', 'LCURLY_BLOCK', 'StatementListopt', 'RCURLY');
2895             }
2896             }
2897              
2898 0           return $rc;
2899             }
2900              
2901              
2902              
2903             sub G1_157 {
2904 0     0 1   my ($self, $value, $index) = @_;
2905              
2906 0           my $rc = '';
2907              
2908 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 157, $value, $index, 'StatementList', 'Statement')) {
  0            
  0            
2909 0 0         if ($index == 0) {
2910             }
2911             }
2912              
2913 0           return $rc;
2914             }
2915              
2916              
2917              
2918             sub G1_158 {
2919 0     0 1   my ($self, $value, $index) = @_;
2920              
2921 0           my $rc = '';
2922              
2923 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 158, $value, $index, 'StatementList', 'StatementList', 'Statement')) {
  0            
  0            
2924 0 0         if ($index == 0) {
    0          
2925             }
2926             elsif ($index == 1) {
2927             }
2928             }
2929              
2930 0           return $rc;
2931             }
2932              
2933              
2934              
2935             sub G1_159 {
2936 0     0 1   my ($self, $value, $index) = @_;
2937              
2938 0           my $rc = '';
2939              
2940 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 159, $value, $index, 'VariableStatement', 'VAR', 'VariableDeclarationList', 'SEMICOLON')) {
  0            
  0            
2941 0 0         if ($index == 0) {
    0          
    0          
2942 0           $rc = $self->lexeme('VAR', 159, $value, 0, 'VariableStatement', 'VAR', 'VariableDeclarationList', 'SEMICOLON');
2943             }
2944             elsif ($index == 1) {
2945             }
2946             elsif ($index == 2) {
2947 0           $rc = $self->lexeme('SEMICOLON', 159, $value, 2, 'VariableStatement', 'VAR', 'VariableDeclarationList', 'SEMICOLON');
2948             }
2949             }
2950              
2951 0           return $rc;
2952             }
2953              
2954              
2955              
2956             sub G1_160 {
2957 0     0 1   my ($self, $value, $index) = @_;
2958              
2959 0           my $rc = '';
2960              
2961 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 160, $value, $index, 'VariableDeclarationList', 'VariableDeclaration')) {
  0            
  0            
2962 0 0         if ($index == 0) {
2963             }
2964             }
2965              
2966 0           return $rc;
2967             }
2968              
2969              
2970              
2971             sub G1_161 {
2972 0     0 1   my ($self, $value, $index) = @_;
2973              
2974 0           my $rc = '';
2975              
2976 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 161, $value, $index, 'VariableDeclarationList', 'VariableDeclarationList', 'COMMA', 'VariableDeclaration')) {
  0            
  0            
2977 0 0         if ($index == 0) {
    0          
    0          
2978             }
2979             elsif ($index == 1) {
2980 0           $rc = $self->lexeme('COMMA', 161, $value, 1, 'VariableDeclarationList', 'VariableDeclarationList', 'COMMA', 'VariableDeclaration');
2981             }
2982             elsif ($index == 2) {
2983             }
2984             }
2985              
2986 0           return $rc;
2987             }
2988              
2989              
2990              
2991             sub G1_162 {
2992 0     0 1   my ($self, $value, $index) = @_;
2993              
2994 0           my $rc = '';
2995              
2996 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 162, $value, $index, 'VariableDeclarationListNoIn', 'VariableDeclarationNoIn')) {
  0            
  0            
2997 0 0         if ($index == 0) {
2998             }
2999             }
3000              
3001 0           return $rc;
3002             }
3003              
3004              
3005              
3006             sub G1_163 {
3007 0     0 1   my ($self, $value, $index) = @_;
3008              
3009 0           my $rc = '';
3010              
3011 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 163, $value, $index, 'VariableDeclarationListNoIn', 'VariableDeclarationListNoIn', 'COMMA', 'VariableDeclarationNoIn')) {
  0            
  0            
3012 0 0         if ($index == 0) {
    0          
    0          
3013             }
3014             elsif ($index == 1) {
3015 0           $rc = $self->lexeme('COMMA', 163, $value, 1, 'VariableDeclarationListNoIn', 'VariableDeclarationListNoIn', 'COMMA', 'VariableDeclarationNoIn');
3016             }
3017             elsif ($index == 2) {
3018             }
3019             }
3020              
3021 0           return $rc;
3022             }
3023              
3024              
3025              
3026             sub G1_164 {
3027 0     0 1   my ($self, $value, $index) = @_;
3028              
3029 0           my $rc = '';
3030              
3031 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 164, $value, $index, 'VariableDeclaration', 'IDENTIFIER', 'Initialiseropt')) {
  0            
  0            
3032 0 0         if ($index == 0) {
    0          
3033 0           $rc = $self->lexeme('IDENTIFIER', 164, $value, 0, 'VariableDeclaration', 'IDENTIFIER', 'Initialiseropt');
3034             }
3035             elsif ($index == 1) {
3036             }
3037             }
3038              
3039 0           return $rc;
3040             }
3041              
3042              
3043              
3044             sub G1_165 {
3045 0     0 1   my ($self, $value, $index) = @_;
3046              
3047 0           my $rc = '';
3048              
3049 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 165, $value, $index, 'VariableDeclarationNoIn', 'IDENTIFIER', 'InitialiserNoInopt')) {
  0            
  0            
3050 0 0         if ($index == 0) {
    0          
3051 0           $rc = $self->lexeme('IDENTIFIER', 165, $value, 0, 'VariableDeclarationNoIn', 'IDENTIFIER', 'InitialiserNoInopt');
3052             }
3053             elsif ($index == 1) {
3054             }
3055             }
3056              
3057 0           return $rc;
3058             }
3059              
3060              
3061              
3062             sub G1_166 {
3063 0     0 1   my ($self, $value, $index) = @_;
3064              
3065 0           my $rc = '';
3066              
3067 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 166, $value, $index, 'Initialiseropt', 'Initialiser')) {
  0            
  0            
3068 0 0         if ($index == 0) {
3069             }
3070             }
3071              
3072 0           return $rc;
3073             }
3074              
3075              
3076              
3077             sub G1_167 {
3078 0     0 1   my ($self, $value, $index) = @_;
3079              
3080 0           my $rc = '';
3081              
3082 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 167, $value, $index, 'Initialiseropt', )) {
  0            
  0            
3083             }
3084              
3085 0           return $rc;
3086             }
3087              
3088              
3089              
3090             sub G1_168 {
3091 0     0 1   my ($self, $value, $index) = @_;
3092              
3093 0           my $rc = '';
3094              
3095 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 168, $value, $index, 'Initialiser', 'ASSIGN', 'AssignmentExpression')) {
  0            
  0            
3096 0 0         if ($index == 0) {
    0          
3097 0           $rc = $self->lexeme('ASSIGN', 168, $value, 0, 'Initialiser', 'ASSIGN', 'AssignmentExpression');
3098             }
3099             elsif ($index == 1) {
3100             }
3101             }
3102              
3103 0           return $rc;
3104             }
3105              
3106              
3107              
3108             sub G1_169 {
3109 0     0 1   my ($self, $value, $index) = @_;
3110              
3111 0           my $rc = '';
3112              
3113 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 169, $value, $index, 'InitialiserNoInopt', 'InitialiserNoIn')) {
  0            
  0            
3114 0 0         if ($index == 0) {
3115             }
3116             }
3117              
3118 0           return $rc;
3119             }
3120              
3121              
3122              
3123             sub G1_170 {
3124 0     0 1   my ($self, $value, $index) = @_;
3125              
3126 0           my $rc = '';
3127              
3128 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 170, $value, $index, 'InitialiserNoInopt', )) {
  0            
  0            
3129             }
3130              
3131 0           return $rc;
3132             }
3133              
3134              
3135              
3136             sub G1_171 {
3137 0     0 1   my ($self, $value, $index) = @_;
3138              
3139 0           my $rc = '';
3140              
3141 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 171, $value, $index, 'InitialiserNoIn', 'ASSIGN', 'AssignmentExpressionNoIn')) {
  0            
  0            
3142 0 0         if ($index == 0) {
    0          
3143 0           $rc = $self->lexeme('ASSIGN', 171, $value, 0, 'InitialiserNoIn', 'ASSIGN', 'AssignmentExpressionNoIn');
3144             }
3145             elsif ($index == 1) {
3146             }
3147             }
3148              
3149 0           return $rc;
3150             }
3151              
3152              
3153              
3154             sub G1_172 {
3155 0     0 1   my ($self, $value, $index) = @_;
3156              
3157 0           my $rc = '';
3158              
3159 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 172, $value, $index, 'EmptyStatement', 'VISIBLE_SEMICOLON')) {
  0            
  0            
3160 0 0         if ($index == 0) {
3161 0           $rc = $self->lexeme('VISIBLE_SEMICOLON', 172, $value, 0, 'EmptyStatement', 'VISIBLE_SEMICOLON');
3162             }
3163             }
3164              
3165 0           return $rc;
3166             }
3167              
3168              
3169              
3170             sub G1_173 {
3171 0     0 1   my ($self, $value, $index) = @_;
3172              
3173 0           my $rc = '';
3174              
3175 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 173, $value, $index, 'ExpressionStatement', 'Expression', 'SEMICOLON')) {
  0            
  0            
3176 0 0         if ($index == 0) {
    0          
3177             }
3178             elsif ($index == 1) {
3179 0           $rc = $self->lexeme('SEMICOLON', 173, $value, 1, 'ExpressionStatement', 'Expression', 'SEMICOLON');
3180             }
3181             }
3182              
3183 0           return $rc;
3184             }
3185              
3186              
3187              
3188             sub G1_174 {
3189 0     0 1   my ($self, $value, $index) = @_;
3190              
3191 0           my $rc = '';
3192              
3193 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 174, $value, $index, 'IfStatement', 'IF', 'LPAREN', 'Expression', 'RPAREN', 'Statement', 'ELSE', 'Statement')) {
  0            
  0            
3194 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
    0          
    0          
3195 0           $rc = $self->lexeme('IF', 174, $value, 0, 'IfStatement', 'IF', 'LPAREN', 'Expression', 'RPAREN', 'Statement', 'ELSE', 'Statement');
3196             }
3197             elsif ($index == 1) {
3198 0           $rc = $self->lexeme('LPAREN', 174, $value, 1, 'IfStatement', 'IF', 'LPAREN', 'Expression', 'RPAREN', 'Statement', 'ELSE', 'Statement');
3199             }
3200             elsif ($index == 2) {
3201             }
3202             elsif ($index == 3) {
3203 0           $rc = $self->lexeme('RPAREN', 174, $value, 3, 'IfStatement', 'IF', 'LPAREN', 'Expression', 'RPAREN', 'Statement', 'ELSE', 'Statement');
3204             }
3205             elsif ($index == 4) {
3206             }
3207             elsif ($index == 5) {
3208 0           $rc = $self->lexeme('ELSE', 174, $value, 5, 'IfStatement', 'IF', 'LPAREN', 'Expression', 'RPAREN', 'Statement', 'ELSE', 'Statement');
3209             }
3210             elsif ($index == 6) {
3211             }
3212             }
3213              
3214 0           return $rc;
3215             }
3216              
3217              
3218              
3219             sub G1_175 {
3220 0     0 1   my ($self, $value, $index) = @_;
3221              
3222 0           my $rc = '';
3223              
3224 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 175, $value, $index, 'IfStatement', 'IF', 'LPAREN', 'Expression', 'RPAREN', 'Statement')) {
  0            
  0            
3225 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
3226 0           $rc = $self->lexeme('IF', 175, $value, 0, 'IfStatement', 'IF', 'LPAREN', 'Expression', 'RPAREN', 'Statement');
3227             }
3228             elsif ($index == 1) {
3229 0           $rc = $self->lexeme('LPAREN', 175, $value, 1, 'IfStatement', 'IF', 'LPAREN', 'Expression', 'RPAREN', 'Statement');
3230             }
3231             elsif ($index == 2) {
3232             }
3233             elsif ($index == 3) {
3234 0           $rc = $self->lexeme('RPAREN', 175, $value, 3, 'IfStatement', 'IF', 'LPAREN', 'Expression', 'RPAREN', 'Statement');
3235             }
3236             elsif ($index == 4) {
3237             }
3238             }
3239              
3240 0           return $rc;
3241             }
3242              
3243              
3244              
3245             sub G1_176 {
3246 0     0 1   my ($self, $value, $index) = @_;
3247              
3248 0           my $rc = '';
3249              
3250 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 176, $value, $index, 'ExpressionNoInopt', 'ExpressionNoIn')) {
  0            
  0            
3251 0 0         if ($index == 0) {
3252             }
3253             }
3254              
3255 0           return $rc;
3256             }
3257              
3258              
3259              
3260             sub G1_177 {
3261 0     0 1   my ($self, $value, $index) = @_;
3262              
3263 0           my $rc = '';
3264              
3265 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 177, $value, $index, 'ExpressionNoInopt', )) {
  0            
  0            
3266             }
3267              
3268 0           return $rc;
3269             }
3270              
3271              
3272              
3273             sub G1_178 {
3274 0     0 1   my ($self, $value, $index) = @_;
3275              
3276 0           my $rc = '';
3277              
3278 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 178, $value, $index, 'Expressionopt', 'Expression')) {
  0            
  0            
3279 0 0         if ($index == 0) {
3280             }
3281             }
3282              
3283 0           return $rc;
3284             }
3285              
3286              
3287              
3288             sub G1_179 {
3289 0     0 1   my ($self, $value, $index) = @_;
3290              
3291 0           my $rc = '';
3292              
3293 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 179, $value, $index, 'Expressionopt', )) {
  0            
  0            
3294             }
3295              
3296 0           return $rc;
3297             }
3298              
3299              
3300              
3301             sub G1_180 {
3302 0     0 1   my ($self, $value, $index) = @_;
3303              
3304 0           my $rc = '';
3305              
3306 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 180, $value, $index, 'IterationStatement', 'DO', 'Statement', 'WHILE', 'LPAREN', 'Expression', 'RPAREN', 'SEMICOLON')) {
  0            
  0            
3307 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
    0          
    0          
3308 0           $rc = $self->lexeme('DO', 180, $value, 0, 'IterationStatement', 'DO', 'Statement', 'WHILE', 'LPAREN', 'Expression', 'RPAREN', 'SEMICOLON');
3309             }
3310             elsif ($index == 1) {
3311             }
3312             elsif ($index == 2) {
3313 0           $rc = $self->lexeme('WHILE', 180, $value, 2, 'IterationStatement', 'DO', 'Statement', 'WHILE', 'LPAREN', 'Expression', 'RPAREN', 'SEMICOLON');
3314             }
3315             elsif ($index == 3) {
3316 0           $rc = $self->lexeme('LPAREN', 180, $value, 3, 'IterationStatement', 'DO', 'Statement', 'WHILE', 'LPAREN', 'Expression', 'RPAREN', 'SEMICOLON');
3317             }
3318             elsif ($index == 4) {
3319             }
3320             elsif ($index == 5) {
3321 0           $rc = $self->lexeme('RPAREN', 180, $value, 5, 'IterationStatement', 'DO', 'Statement', 'WHILE', 'LPAREN', 'Expression', 'RPAREN', 'SEMICOLON');
3322             }
3323             elsif ($index == 6) {
3324 0           $rc = $self->lexeme('SEMICOLON', 180, $value, 6, 'IterationStatement', 'DO', 'Statement', 'WHILE', 'LPAREN', 'Expression', 'RPAREN', 'SEMICOLON');
3325             }
3326             }
3327              
3328 0           return $rc;
3329             }
3330              
3331              
3332              
3333             sub G1_181 {
3334 0     0 1   my ($self, $value, $index) = @_;
3335              
3336 0           my $rc = '';
3337              
3338 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 181, $value, $index, 'IterationStatement', 'WHILE', 'LPAREN', 'Expression', 'RPAREN', 'Statement')) {
  0            
  0            
3339 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
3340 0           $rc = $self->lexeme('WHILE', 181, $value, 0, 'IterationStatement', 'WHILE', 'LPAREN', 'Expression', 'RPAREN', 'Statement');
3341             }
3342             elsif ($index == 1) {
3343 0           $rc = $self->lexeme('LPAREN', 181, $value, 1, 'IterationStatement', 'WHILE', 'LPAREN', 'Expression', 'RPAREN', 'Statement');
3344             }
3345             elsif ($index == 2) {
3346             }
3347             elsif ($index == 3) {
3348 0           $rc = $self->lexeme('RPAREN', 181, $value, 3, 'IterationStatement', 'WHILE', 'LPAREN', 'Expression', 'RPAREN', 'Statement');
3349             }
3350             elsif ($index == 4) {
3351             }
3352             }
3353              
3354 0           return $rc;
3355             }
3356              
3357              
3358              
3359             sub G1_182 {
3360 0     0 1   my ($self, $value, $index) = @_;
3361              
3362 0           my $rc = '';
3363              
3364 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 182, $value, $index, 'IterationStatement', 'FOR', 'LPAREN', 'ExpressionNoInopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement')) {
  0            
  0            
3365 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
3366 0           $rc = $self->lexeme('FOR', 182, $value, 0, 'IterationStatement', 'FOR', 'LPAREN', 'ExpressionNoInopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3367             }
3368             elsif ($index == 1) {
3369 0           $rc = $self->lexeme('LPAREN', 182, $value, 1, 'IterationStatement', 'FOR', 'LPAREN', 'ExpressionNoInopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3370             }
3371             elsif ($index == 2) {
3372             }
3373             elsif ($index == 3) {
3374 0           $rc = $self->lexeme('VISIBLE_SEMICOLON', 182, $value, 3, 'IterationStatement', 'FOR', 'LPAREN', 'ExpressionNoInopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3375             }
3376             elsif ($index == 4) {
3377             }
3378             elsif ($index == 5) {
3379 0           $rc = $self->lexeme('VISIBLE_SEMICOLON', 182, $value, 5, 'IterationStatement', 'FOR', 'LPAREN', 'ExpressionNoInopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3380             }
3381             elsif ($index == 6) {
3382             }
3383             elsif ($index == 7) {
3384 0           $rc = $self->lexeme('RPAREN', 182, $value, 7, 'IterationStatement', 'FOR', 'LPAREN', 'ExpressionNoInopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3385             }
3386             elsif ($index == 8) {
3387             }
3388             }
3389              
3390 0           return $rc;
3391             }
3392              
3393              
3394              
3395             sub G1_183 {
3396 0     0 1   my ($self, $value, $index) = @_;
3397              
3398 0           my $rc = '';
3399              
3400 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 183, $value, $index, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationListNoIn', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement')) {
  0            
  0            
3401 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
3402 0           $rc = $self->lexeme('FOR', 183, $value, 0, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationListNoIn', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3403             }
3404             elsif ($index == 1) {
3405 0           $rc = $self->lexeme('LPAREN', 183, $value, 1, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationListNoIn', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3406             }
3407             elsif ($index == 2) {
3408 0           $rc = $self->lexeme('VAR', 183, $value, 2, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationListNoIn', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3409             }
3410             elsif ($index == 3) {
3411             }
3412             elsif ($index == 4) {
3413 0           $rc = $self->lexeme('VISIBLE_SEMICOLON', 183, $value, 4, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationListNoIn', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3414             }
3415             elsif ($index == 5) {
3416             }
3417             elsif ($index == 6) {
3418 0           $rc = $self->lexeme('VISIBLE_SEMICOLON', 183, $value, 6, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationListNoIn', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3419             }
3420             elsif ($index == 7) {
3421             }
3422             elsif ($index == 8) {
3423 0           $rc = $self->lexeme('RPAREN', 183, $value, 8, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationListNoIn', 'VISIBLE_SEMICOLON', 'Expressionopt', 'VISIBLE_SEMICOLON', 'Expressionopt', 'RPAREN', 'Statement');
3424             }
3425             elsif ($index == 9) {
3426             }
3427             }
3428              
3429 0           return $rc;
3430             }
3431              
3432              
3433              
3434             sub G1_184 {
3435 0     0 1   my ($self, $value, $index) = @_;
3436              
3437 0           my $rc = '';
3438              
3439 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 184, $value, $index, 'IterationStatement', 'FOR', 'LPAREN', 'LeftHandSideExpression', 'IN', 'Expression', 'RPAREN', 'Statement')) {
  0            
  0            
3440 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
    0          
    0          
3441 0           $rc = $self->lexeme('FOR', 184, $value, 0, 'IterationStatement', 'FOR', 'LPAREN', 'LeftHandSideExpression', 'IN', 'Expression', 'RPAREN', 'Statement');
3442             }
3443             elsif ($index == 1) {
3444 0           $rc = $self->lexeme('LPAREN', 184, $value, 1, 'IterationStatement', 'FOR', 'LPAREN', 'LeftHandSideExpression', 'IN', 'Expression', 'RPAREN', 'Statement');
3445             }
3446             elsif ($index == 2) {
3447             }
3448             elsif ($index == 3) {
3449 0           $rc = $self->lexeme('IN', 184, $value, 3, 'IterationStatement', 'FOR', 'LPAREN', 'LeftHandSideExpression', 'IN', 'Expression', 'RPAREN', 'Statement');
3450             }
3451             elsif ($index == 4) {
3452             }
3453             elsif ($index == 5) {
3454 0           $rc = $self->lexeme('RPAREN', 184, $value, 5, 'IterationStatement', 'FOR', 'LPAREN', 'LeftHandSideExpression', 'IN', 'Expression', 'RPAREN', 'Statement');
3455             }
3456             elsif ($index == 6) {
3457             }
3458             }
3459              
3460 0           return $rc;
3461             }
3462              
3463              
3464              
3465             sub G1_185 {
3466 0     0 1   my ($self, $value, $index) = @_;
3467              
3468 0           my $rc = '';
3469              
3470 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 185, $value, $index, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationNoIn', 'IN', 'Expression', 'RPAREN', 'Statement')) {
  0            
  0            
3471 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
    0          
    0          
    0          
3472 0           $rc = $self->lexeme('FOR', 185, $value, 0, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationNoIn', 'IN', 'Expression', 'RPAREN', 'Statement');
3473             }
3474             elsif ($index == 1) {
3475 0           $rc = $self->lexeme('LPAREN', 185, $value, 1, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationNoIn', 'IN', 'Expression', 'RPAREN', 'Statement');
3476             }
3477             elsif ($index == 2) {
3478 0           $rc = $self->lexeme('VAR', 185, $value, 2, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationNoIn', 'IN', 'Expression', 'RPAREN', 'Statement');
3479             }
3480             elsif ($index == 3) {
3481             }
3482             elsif ($index == 4) {
3483 0           $rc = $self->lexeme('IN', 185, $value, 4, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationNoIn', 'IN', 'Expression', 'RPAREN', 'Statement');
3484             }
3485             elsif ($index == 5) {
3486             }
3487             elsif ($index == 6) {
3488 0           $rc = $self->lexeme('RPAREN', 185, $value, 6, 'IterationStatement', 'FOR', 'LPAREN', 'VAR', 'VariableDeclarationNoIn', 'IN', 'Expression', 'RPAREN', 'Statement');
3489             }
3490             elsif ($index == 7) {
3491             }
3492             }
3493              
3494 0           return $rc;
3495             }
3496              
3497              
3498              
3499             sub G1_186 {
3500 0     0 1   my ($self, $value, $index) = @_;
3501              
3502 0           my $rc = '';
3503              
3504 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 186, $value, $index, 'ContinueStatement', 'CONTINUE', 'SEMICOLON')) {
  0            
  0            
3505 0 0         if ($index == 0) {
    0          
3506 0           $rc = $self->lexeme('CONTINUE', 186, $value, 0, 'ContinueStatement', 'CONTINUE', 'SEMICOLON');
3507             }
3508             elsif ($index == 1) {
3509 0           $rc = $self->lexeme('SEMICOLON', 186, $value, 1, 'ContinueStatement', 'CONTINUE', 'SEMICOLON');
3510             }
3511             }
3512              
3513 0           return $rc;
3514             }
3515              
3516              
3517              
3518             sub G1_187 {
3519 0     0 1   my ($self, $value, $index) = @_;
3520              
3521 0           my $rc = '';
3522              
3523 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 187, $value, $index, 'ContinueStatement', 'CONTINUE', 'INVISIBLE_SEMICOLON')) {
  0            
  0            
3524 0 0         if ($index == 0) {
    0          
3525 0           $rc = $self->lexeme('CONTINUE', 187, $value, 0, 'ContinueStatement', 'CONTINUE', 'INVISIBLE_SEMICOLON');
3526             }
3527             elsif ($index == 1) {
3528 0           $rc = $self->lexeme('INVISIBLE_SEMICOLON', 187, $value, 1, 'ContinueStatement', 'CONTINUE', 'INVISIBLE_SEMICOLON');
3529             }
3530             }
3531              
3532 0           return $rc;
3533             }
3534              
3535              
3536              
3537             sub G1_188 {
3538 0     0 1   my ($self, $value, $index) = @_;
3539              
3540 0           my $rc = '';
3541              
3542 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 188, $value, $index, 'ContinueStatement', 'CONTINUE', 'IDENTIFIER', 'SEMICOLON')) {
  0            
  0            
3543 0 0         if ($index == 0) {
    0          
    0          
3544 0           $rc = $self->lexeme('CONTINUE', 188, $value, 0, 'ContinueStatement', 'CONTINUE', 'IDENTIFIER', 'SEMICOLON');
3545             }
3546             elsif ($index == 1) {
3547 0           $rc = $self->lexeme('IDENTIFIER', 188, $value, 1, 'ContinueStatement', 'CONTINUE', 'IDENTIFIER', 'SEMICOLON');
3548             }
3549             elsif ($index == 2) {
3550 0           $rc = $self->lexeme('SEMICOLON', 188, $value, 2, 'ContinueStatement', 'CONTINUE', 'IDENTIFIER', 'SEMICOLON');
3551             }
3552             }
3553              
3554 0           return $rc;
3555             }
3556              
3557              
3558              
3559             sub G1_189 {
3560 0     0 1   my ($self, $value, $index) = @_;
3561              
3562 0           my $rc = '';
3563              
3564 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 189, $value, $index, 'BreakStatement', 'BREAK', 'SEMICOLON')) {
  0            
  0            
3565 0 0         if ($index == 0) {
    0          
3566 0           $rc = $self->lexeme('BREAK', 189, $value, 0, 'BreakStatement', 'BREAK', 'SEMICOLON');
3567             }
3568             elsif ($index == 1) {
3569 0           $rc = $self->lexeme('SEMICOLON', 189, $value, 1, 'BreakStatement', 'BREAK', 'SEMICOLON');
3570             }
3571             }
3572              
3573 0           return $rc;
3574             }
3575              
3576              
3577              
3578             sub G1_190 {
3579 0     0 1   my ($self, $value, $index) = @_;
3580              
3581 0           my $rc = '';
3582              
3583 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 190, $value, $index, 'BreakStatement', 'BREAK', 'INVISIBLE_SEMICOLON')) {
  0            
  0            
3584 0 0         if ($index == 0) {
    0          
3585 0           $rc = $self->lexeme('BREAK', 190, $value, 0, 'BreakStatement', 'BREAK', 'INVISIBLE_SEMICOLON');
3586             }
3587             elsif ($index == 1) {
3588 0           $rc = $self->lexeme('INVISIBLE_SEMICOLON', 190, $value, 1, 'BreakStatement', 'BREAK', 'INVISIBLE_SEMICOLON');
3589             }
3590             }
3591              
3592 0           return $rc;
3593             }
3594              
3595              
3596              
3597             sub G1_191 {
3598 0     0 1   my ($self, $value, $index) = @_;
3599              
3600 0           my $rc = '';
3601              
3602 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 191, $value, $index, 'BreakStatement', 'BREAK', 'IDENTIFIER', 'SEMICOLON')) {
  0            
  0            
3603 0 0         if ($index == 0) {
    0          
    0          
3604 0           $rc = $self->lexeme('BREAK', 191, $value, 0, 'BreakStatement', 'BREAK', 'IDENTIFIER', 'SEMICOLON');
3605             }
3606             elsif ($index == 1) {
3607 0           $rc = $self->lexeme('IDENTIFIER', 191, $value, 1, 'BreakStatement', 'BREAK', 'IDENTIFIER', 'SEMICOLON');
3608             }
3609             elsif ($index == 2) {
3610 0           $rc = $self->lexeme('SEMICOLON', 191, $value, 2, 'BreakStatement', 'BREAK', 'IDENTIFIER', 'SEMICOLON');
3611             }
3612             }
3613              
3614 0           return $rc;
3615             }
3616              
3617              
3618              
3619             sub G1_192 {
3620 0     0 1   my ($self, $value, $index) = @_;
3621              
3622 0           my $rc = '';
3623              
3624 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 192, $value, $index, 'ReturnStatement', 'RETURN', 'SEMICOLON')) {
  0            
  0            
3625 0 0         if ($index == 0) {
    0          
3626 0           $rc = $self->lexeme('RETURN', 192, $value, 0, 'ReturnStatement', 'RETURN', 'SEMICOLON');
3627             }
3628             elsif ($index == 1) {
3629 0           $rc = $self->lexeme('SEMICOLON', 192, $value, 1, 'ReturnStatement', 'RETURN', 'SEMICOLON');
3630             }
3631             }
3632              
3633 0           return $rc;
3634             }
3635              
3636              
3637              
3638             sub G1_193 {
3639 0     0 1   my ($self, $value, $index) = @_;
3640              
3641 0           my $rc = '';
3642              
3643 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 193, $value, $index, 'ReturnStatement', 'RETURN', 'INVISIBLE_SEMICOLON')) {
  0            
  0            
3644 0 0         if ($index == 0) {
    0          
3645 0           $rc = $self->lexeme('RETURN', 193, $value, 0, 'ReturnStatement', 'RETURN', 'INVISIBLE_SEMICOLON');
3646             }
3647             elsif ($index == 1) {
3648 0           $rc = $self->lexeme('INVISIBLE_SEMICOLON', 193, $value, 1, 'ReturnStatement', 'RETURN', 'INVISIBLE_SEMICOLON');
3649             }
3650             }
3651              
3652 0           return $rc;
3653             }
3654              
3655              
3656              
3657             sub G1_194 {
3658 0     0 1   my ($self, $value, $index) = @_;
3659              
3660 0           my $rc = '';
3661              
3662 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 194, $value, $index, 'ReturnStatement', 'RETURN', 'Expression', 'SEMICOLON')) {
  0            
  0            
3663 0 0         if ($index == 0) {
    0          
    0          
3664 0           $rc = $self->lexeme('RETURN', 194, $value, 0, 'ReturnStatement', 'RETURN', 'Expression', 'SEMICOLON');
3665             }
3666             elsif ($index == 1) {
3667             }
3668             elsif ($index == 2) {
3669 0           $rc = $self->lexeme('SEMICOLON', 194, $value, 2, 'ReturnStatement', 'RETURN', 'Expression', 'SEMICOLON');
3670             }
3671             }
3672              
3673 0           return $rc;
3674             }
3675              
3676              
3677              
3678             sub G1_195 {
3679 0     0 1   my ($self, $value, $index) = @_;
3680              
3681 0           my $rc = '';
3682              
3683 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 195, $value, $index, 'WithStatement', 'WITH', 'LPAREN', 'Expression', 'RPAREN', 'Statement')) {
  0            
  0            
3684 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
3685 0           $rc = $self->lexeme('WITH', 195, $value, 0, 'WithStatement', 'WITH', 'LPAREN', 'Expression', 'RPAREN', 'Statement');
3686             }
3687             elsif ($index == 1) {
3688 0           $rc = $self->lexeme('LPAREN', 195, $value, 1, 'WithStatement', 'WITH', 'LPAREN', 'Expression', 'RPAREN', 'Statement');
3689             }
3690             elsif ($index == 2) {
3691             }
3692             elsif ($index == 3) {
3693 0           $rc = $self->lexeme('RPAREN', 195, $value, 3, 'WithStatement', 'WITH', 'LPAREN', 'Expression', 'RPAREN', 'Statement');
3694             }
3695             elsif ($index == 4) {
3696             }
3697             }
3698              
3699 0           return $rc;
3700             }
3701              
3702              
3703              
3704             sub G1_196 {
3705 0     0 1   my ($self, $value, $index) = @_;
3706              
3707 0           my $rc = '';
3708              
3709 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 196, $value, $index, 'SwitchStatement', 'SWITCH', 'LPAREN', 'Expression', 'RPAREN', 'CaseBlock')) {
  0            
  0            
3710 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
3711 0           $rc = $self->lexeme('SWITCH', 196, $value, 0, 'SwitchStatement', 'SWITCH', 'LPAREN', 'Expression', 'RPAREN', 'CaseBlock');
3712             }
3713             elsif ($index == 1) {
3714 0           $rc = $self->lexeme('LPAREN', 196, $value, 1, 'SwitchStatement', 'SWITCH', 'LPAREN', 'Expression', 'RPAREN', 'CaseBlock');
3715             }
3716             elsif ($index == 2) {
3717             }
3718             elsif ($index == 3) {
3719 0           $rc = $self->lexeme('RPAREN', 196, $value, 3, 'SwitchStatement', 'SWITCH', 'LPAREN', 'Expression', 'RPAREN', 'CaseBlock');
3720             }
3721             elsif ($index == 4) {
3722             }
3723             }
3724              
3725 0           return $rc;
3726             }
3727              
3728              
3729              
3730             sub G1_197 {
3731 0     0 1   my ($self, $value, $index) = @_;
3732              
3733 0           my $rc = '';
3734              
3735 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 197, $value, $index, 'CaseBlock', 'LCURLY', 'CaseClausesopt', 'RCURLY')) {
  0            
  0            
3736 0 0         if ($index == 0) {
    0          
    0          
3737 0           $rc = $self->lexeme('LCURLY', 197, $value, 0, 'CaseBlock', 'LCURLY', 'CaseClausesopt', 'RCURLY');
3738             }
3739             elsif ($index == 1) {
3740             }
3741             elsif ($index == 2) {
3742 0           $rc = $self->lexeme('RCURLY', 197, $value, 2, 'CaseBlock', 'LCURLY', 'CaseClausesopt', 'RCURLY');
3743             }
3744             }
3745              
3746 0           return $rc;
3747             }
3748              
3749              
3750              
3751             sub G1_198 {
3752 0     0 1   my ($self, $value, $index) = @_;
3753              
3754 0           my $rc = '';
3755              
3756 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 198, $value, $index, 'CaseBlock', 'LCURLY', 'CaseClausesopt', 'DefaultClause', 'CaseClausesopt', 'RCURLY')) {
  0            
  0            
3757 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
3758 0           $rc = $self->lexeme('LCURLY', 198, $value, 0, 'CaseBlock', 'LCURLY', 'CaseClausesopt', 'DefaultClause', 'CaseClausesopt', 'RCURLY');
3759             }
3760             elsif ($index == 1) {
3761             }
3762             elsif ($index == 2) {
3763             }
3764             elsif ($index == 3) {
3765             }
3766             elsif ($index == 4) {
3767 0           $rc = $self->lexeme('RCURLY', 198, $value, 4, 'CaseBlock', 'LCURLY', 'CaseClausesopt', 'DefaultClause', 'CaseClausesopt', 'RCURLY');
3768             }
3769             }
3770              
3771 0           return $rc;
3772             }
3773              
3774              
3775              
3776             sub G1_199 {
3777 0     0 1   my ($self, $value, $index) = @_;
3778              
3779 0           my $rc = '';
3780              
3781 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 199, $value, $index, 'CaseClausesopt', 'CaseClauses')) {
  0            
  0            
3782 0 0         if ($index == 0) {
3783             }
3784             }
3785              
3786 0           return $rc;
3787             }
3788              
3789              
3790              
3791             sub G1_200 {
3792 0     0 1   my ($self, $value, $index) = @_;
3793              
3794 0           my $rc = '';
3795              
3796 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 200, $value, $index, 'CaseClausesopt', )) {
  0            
  0            
3797             }
3798              
3799 0           return $rc;
3800             }
3801              
3802              
3803              
3804             sub G1_201 {
3805 0     0 1   my ($self, $value, $index) = @_;
3806              
3807 0           my $rc = '';
3808              
3809 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 201, $value, $index, 'CaseClauses', 'CaseClause')) {
  0            
  0            
3810 0 0         if ($index == 0) {
3811             }
3812             }
3813              
3814 0           return $rc;
3815             }
3816              
3817              
3818              
3819             sub G1_202 {
3820 0     0 1   my ($self, $value, $index) = @_;
3821              
3822 0           my $rc = '';
3823              
3824 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 202, $value, $index, 'CaseClauses', 'CaseClauses', 'CaseClause')) {
  0            
  0            
3825 0 0         if ($index == 0) {
    0          
3826             }
3827             elsif ($index == 1) {
3828             }
3829             }
3830              
3831 0           return $rc;
3832             }
3833              
3834              
3835              
3836             sub G1_203 {
3837 0     0 1   my ($self, $value, $index) = @_;
3838              
3839 0           my $rc = '';
3840              
3841 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 203, $value, $index, 'CaseClause', 'CASE', 'Expression', 'COLON', 'StatementListopt')) {
  0            
  0            
3842 0 0         if ($index == 0) {
    0          
    0          
    0          
3843 0           $rc = $self->lexeme('CASE', 203, $value, 0, 'CaseClause', 'CASE', 'Expression', 'COLON', 'StatementListopt');
3844             }
3845             elsif ($index == 1) {
3846             }
3847             elsif ($index == 2) {
3848 0           $rc = $self->lexeme('COLON', 203, $value, 2, 'CaseClause', 'CASE', 'Expression', 'COLON', 'StatementListopt');
3849             }
3850             elsif ($index == 3) {
3851             }
3852             }
3853              
3854 0           return $rc;
3855             }
3856              
3857              
3858              
3859             sub G1_204 {
3860 0     0 1   my ($self, $value, $index) = @_;
3861              
3862 0           my $rc = '';
3863              
3864 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 204, $value, $index, 'StatementListopt', 'StatementList')) {
  0            
  0            
3865 0 0         if ($index == 0) {
3866             }
3867             }
3868              
3869 0           return $rc;
3870             }
3871              
3872              
3873              
3874             sub G1_205 {
3875 0     0 1   my ($self, $value, $index) = @_;
3876              
3877 0           my $rc = '';
3878              
3879 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 205, $value, $index, 'StatementListopt', )) {
  0            
  0            
3880             }
3881              
3882 0           return $rc;
3883             }
3884              
3885              
3886              
3887             sub G1_206 {
3888 0     0 1   my ($self, $value, $index) = @_;
3889              
3890 0           my $rc = '';
3891              
3892 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 206, $value, $index, 'DefaultClause', 'DEFAULT', 'COLON', 'StatementListopt')) {
  0            
  0            
3893 0 0         if ($index == 0) {
    0          
    0          
3894 0           $rc = $self->lexeme('DEFAULT', 206, $value, 0, 'DefaultClause', 'DEFAULT', 'COLON', 'StatementListopt');
3895             }
3896             elsif ($index == 1) {
3897 0           $rc = $self->lexeme('COLON', 206, $value, 1, 'DefaultClause', 'DEFAULT', 'COLON', 'StatementListopt');
3898             }
3899             elsif ($index == 2) {
3900             }
3901             }
3902              
3903 0           return $rc;
3904             }
3905              
3906              
3907              
3908             sub G1_207 {
3909 0     0 1   my ($self, $value, $index) = @_;
3910              
3911 0           my $rc = '';
3912              
3913 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 207, $value, $index, 'LabelledStatement', 'IDENTIFIER', 'COLON', 'Statement')) {
  0            
  0            
3914 0 0         if ($index == 0) {
    0          
    0          
3915 0           $rc = $self->lexeme('IDENTIFIER', 207, $value, 0, 'LabelledStatement', 'IDENTIFIER', 'COLON', 'Statement');
3916             }
3917             elsif ($index == 1) {
3918 0           $rc = $self->lexeme('COLON', 207, $value, 1, 'LabelledStatement', 'IDENTIFIER', 'COLON', 'Statement');
3919             }
3920             elsif ($index == 2) {
3921             }
3922             }
3923              
3924 0           return $rc;
3925             }
3926              
3927              
3928              
3929             sub G1_208 {
3930 0     0 1   my ($self, $value, $index) = @_;
3931              
3932 0           my $rc = '';
3933              
3934 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 208, $value, $index, 'ThrowStatement', 'THROW', 'Expression', 'SEMICOLON')) {
  0            
  0            
3935 0 0         if ($index == 0) {
    0          
    0          
3936 0           $rc = $self->lexeme('THROW', 208, $value, 0, 'ThrowStatement', 'THROW', 'Expression', 'SEMICOLON');
3937             }
3938             elsif ($index == 1) {
3939             }
3940             elsif ($index == 2) {
3941 0           $rc = $self->lexeme('SEMICOLON', 208, $value, 2, 'ThrowStatement', 'THROW', 'Expression', 'SEMICOLON');
3942             }
3943             }
3944              
3945 0           return $rc;
3946             }
3947              
3948              
3949              
3950             sub G1_209 {
3951 0     0 1   my ($self, $value, $index) = @_;
3952              
3953 0           my $rc = '';
3954              
3955 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 209, $value, $index, 'TryStatement', 'TRY', 'Block', 'Catch')) {
  0            
  0            
3956 0 0         if ($index == 0) {
    0          
    0          
3957 0           $rc = $self->lexeme('TRY', 209, $value, 0, 'TryStatement', 'TRY', 'Block', 'Catch');
3958             }
3959             elsif ($index == 1) {
3960             }
3961             elsif ($index == 2) {
3962             }
3963             }
3964              
3965 0           return $rc;
3966             }
3967              
3968              
3969              
3970             sub G1_210 {
3971 0     0 1   my ($self, $value, $index) = @_;
3972              
3973 0           my $rc = '';
3974              
3975 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 210, $value, $index, 'TryStatement', 'TRY', 'Block', 'Finally')) {
  0            
  0            
3976 0 0         if ($index == 0) {
    0          
    0          
3977 0           $rc = $self->lexeme('TRY', 210, $value, 0, 'TryStatement', 'TRY', 'Block', 'Finally');
3978             }
3979             elsif ($index == 1) {
3980             }
3981             elsif ($index == 2) {
3982             }
3983             }
3984              
3985 0           return $rc;
3986             }
3987              
3988              
3989              
3990             sub G1_211 {
3991 0     0 1   my ($self, $value, $index) = @_;
3992              
3993 0           my $rc = '';
3994              
3995 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 211, $value, $index, 'TryStatement', 'TRY', 'Block', 'Catch', 'Finally')) {
  0            
  0            
3996 0 0         if ($index == 0) {
    0          
    0          
    0          
3997 0           $rc = $self->lexeme('TRY', 211, $value, 0, 'TryStatement', 'TRY', 'Block', 'Catch', 'Finally');
3998             }
3999             elsif ($index == 1) {
4000             }
4001             elsif ($index == 2) {
4002             }
4003             elsif ($index == 3) {
4004             }
4005             }
4006              
4007 0           return $rc;
4008             }
4009              
4010              
4011              
4012             sub G1_212 {
4013 0     0 1   my ($self, $value, $index) = @_;
4014              
4015 0           my $rc = '';
4016              
4017 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 212, $value, $index, 'Catch', 'CATCH', 'LPAREN', 'IDENTIFIER', 'RPAREN', 'Block')) {
  0            
  0            
4018 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
4019 0           $rc = $self->lexeme('CATCH', 212, $value, 0, 'Catch', 'CATCH', 'LPAREN', 'IDENTIFIER', 'RPAREN', 'Block');
4020             }
4021             elsif ($index == 1) {
4022 0           $rc = $self->lexeme('LPAREN', 212, $value, 1, 'Catch', 'CATCH', 'LPAREN', 'IDENTIFIER', 'RPAREN', 'Block');
4023             }
4024             elsif ($index == 2) {
4025 0           $rc = $self->lexeme('IDENTIFIER', 212, $value, 2, 'Catch', 'CATCH', 'LPAREN', 'IDENTIFIER', 'RPAREN', 'Block');
4026             }
4027             elsif ($index == 3) {
4028 0           $rc = $self->lexeme('RPAREN', 212, $value, 3, 'Catch', 'CATCH', 'LPAREN', 'IDENTIFIER', 'RPAREN', 'Block');
4029             }
4030             elsif ($index == 4) {
4031             }
4032             }
4033              
4034 0           return $rc;
4035             }
4036              
4037              
4038              
4039             sub G1_213 {
4040 0     0 1   my ($self, $value, $index) = @_;
4041              
4042 0           my $rc = '';
4043              
4044 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 213, $value, $index, 'Finally', 'FINALLY', 'Block')) {
  0            
  0            
4045 0 0         if ($index == 0) {
    0          
4046 0           $rc = $self->lexeme('FINALLY', 213, $value, 0, 'Finally', 'FINALLY', 'Block');
4047             }
4048             elsif ($index == 1) {
4049             }
4050             }
4051              
4052 0           return $rc;
4053             }
4054              
4055              
4056              
4057             sub G1_214 {
4058 0     0 1   my ($self, $value, $index) = @_;
4059              
4060 0           my $rc = '';
4061              
4062 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 214, $value, $index, 'DebuggerStatement', 'DEBUGGER', 'SEMICOLON')) {
  0            
  0            
4063 0 0         if ($index == 0) {
    0          
4064 0           $rc = $self->lexeme('DEBUGGER', 214, $value, 0, 'DebuggerStatement', 'DEBUGGER', 'SEMICOLON');
4065             }
4066             elsif ($index == 1) {
4067 0           $rc = $self->lexeme('SEMICOLON', 214, $value, 1, 'DebuggerStatement', 'DEBUGGER', 'SEMICOLON');
4068             }
4069             }
4070              
4071 0           return $rc;
4072             }
4073              
4074              
4075              
4076             sub G1_215 {
4077 0     0 1   my ($self, $value, $index) = @_;
4078              
4079 0           my $rc = '';
4080              
4081 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 215, $value, $index, 'FunctionDeclaration', 'FUNCTION', 'IDENTIFIER', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY')) {
  0            
  0            
4082 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
    0          
    0          
    0          
4083 0           $rc = $self->lexeme('FUNCTION', 215, $value, 0, 'FunctionDeclaration', 'FUNCTION', 'IDENTIFIER', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4084             }
4085             elsif ($index == 1) {
4086 0           $rc = $self->lexeme('IDENTIFIER', 215, $value, 1, 'FunctionDeclaration', 'FUNCTION', 'IDENTIFIER', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4087             }
4088             elsif ($index == 2) {
4089 0           $rc = $self->lexeme('LPAREN', 215, $value, 2, 'FunctionDeclaration', 'FUNCTION', 'IDENTIFIER', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4090             }
4091             elsif ($index == 3) {
4092             }
4093             elsif ($index == 4) {
4094 0           $rc = $self->lexeme('RPAREN', 215, $value, 4, 'FunctionDeclaration', 'FUNCTION', 'IDENTIFIER', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4095             }
4096             elsif ($index == 5) {
4097 0           $rc = $self->lexeme('LCURLY', 215, $value, 5, 'FunctionDeclaration', 'FUNCTION', 'IDENTIFIER', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4098             }
4099             elsif ($index == 6) {
4100             }
4101             elsif ($index == 7) {
4102 0           $rc = $self->lexeme('RCURLY', 215, $value, 7, 'FunctionDeclaration', 'FUNCTION', 'IDENTIFIER', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4103             }
4104             }
4105              
4106 0           return $rc;
4107             }
4108              
4109              
4110              
4111             sub G1_216 {
4112 0     0 1   my ($self, $value, $index) = @_;
4113              
4114 0           my $rc = '';
4115              
4116 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 216, $value, $index, 'Identifieropt', 'IDENTIFIER')) {
  0            
  0            
4117 0 0         if ($index == 0) {
4118 0           $rc = $self->lexeme('IDENTIFIER', 216, $value, 0, 'Identifieropt', 'IDENTIFIER');
4119             }
4120             }
4121              
4122 0           return $rc;
4123             }
4124              
4125              
4126              
4127             sub G1_217 {
4128 0     0 1   my ($self, $value, $index) = @_;
4129              
4130 0           my $rc = '';
4131              
4132 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 217, $value, $index, 'Identifieropt', )) {
  0            
  0            
4133             }
4134              
4135 0           return $rc;
4136             }
4137              
4138              
4139              
4140             sub G1_218 {
4141 0     0 1   my ($self, $value, $index) = @_;
4142              
4143 0           my $rc = '';
4144              
4145 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 218, $value, $index, 'FunctionExpression', 'FUNCTION', 'Identifieropt', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY')) {
  0            
  0            
4146 0 0         if ($index == 0) {
    0          
    0          
    0          
    0          
    0          
    0          
    0          
4147 0           $rc = $self->lexeme('FUNCTION', 218, $value, 0, 'FunctionExpression', 'FUNCTION', 'Identifieropt', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4148             }
4149             elsif ($index == 1) {
4150             }
4151             elsif ($index == 2) {
4152 0           $rc = $self->lexeme('LPAREN', 218, $value, 2, 'FunctionExpression', 'FUNCTION', 'Identifieropt', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4153             }
4154             elsif ($index == 3) {
4155             }
4156             elsif ($index == 4) {
4157 0           $rc = $self->lexeme('RPAREN', 218, $value, 4, 'FunctionExpression', 'FUNCTION', 'Identifieropt', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4158             }
4159             elsif ($index == 5) {
4160 0           $rc = $self->lexeme('LCURLY', 218, $value, 5, 'FunctionExpression', 'FUNCTION', 'Identifieropt', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4161             }
4162             elsif ($index == 6) {
4163             }
4164             elsif ($index == 7) {
4165 0           $rc = $self->lexeme('RCURLY', 218, $value, 7, 'FunctionExpression', 'FUNCTION', 'Identifieropt', 'LPAREN', 'FormalParameterListopt', 'RPAREN', 'LCURLY', 'FunctionBody', 'RCURLY');
4166             }
4167             }
4168              
4169 0           return $rc;
4170             }
4171              
4172              
4173              
4174             sub G1_219 {
4175 0     0 1   my ($self, $value, $index) = @_;
4176              
4177 0           my $rc = '';
4178              
4179 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 219, $value, $index, 'FormalParameterListopt', 'FormalParameterList')) {
  0            
  0            
4180 0 0         if ($index == 0) {
4181             }
4182             }
4183              
4184 0           return $rc;
4185             }
4186              
4187              
4188              
4189             sub G1_220 {
4190 0     0 1   my ($self, $value, $index) = @_;
4191              
4192 0           my $rc = '';
4193              
4194 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 220, $value, $index, 'FormalParameterListopt', )) {
  0            
  0            
4195             }
4196              
4197 0           return $rc;
4198             }
4199              
4200              
4201              
4202             sub G1_221 {
4203 0     0 1   my ($self, $value, $index) = @_;
4204              
4205 0           my $rc = '';
4206              
4207 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 221, $value, $index, 'FormalParameterList', 'IDENTIFIER')) {
  0            
  0            
4208 0 0         if ($index == 0) {
4209 0           $rc = $self->lexeme('IDENTIFIER', 221, $value, 0, 'FormalParameterList', 'IDENTIFIER');
4210             }
4211             }
4212              
4213 0           return $rc;
4214             }
4215              
4216              
4217              
4218             sub G1_222 {
4219 0     0 1   my ($self, $value, $index) = @_;
4220              
4221 0           my $rc = '';
4222              
4223 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 222, $value, $index, 'FormalParameterList', 'FormalParameterList', 'COMMA', 'IDENTIFIER')) {
  0            
  0            
4224 0 0         if ($index == 0) {
    0          
    0          
4225             }
4226             elsif ($index == 1) {
4227 0           $rc = $self->lexeme('COMMA', 222, $value, 1, 'FormalParameterList', 'FormalParameterList', 'COMMA', 'IDENTIFIER');
4228             }
4229             elsif ($index == 2) {
4230 0           $rc = $self->lexeme('IDENTIFIER', 222, $value, 2, 'FormalParameterList', 'FormalParameterList', 'COMMA', 'IDENTIFIER');
4231             }
4232             }
4233              
4234 0           return $rc;
4235             }
4236              
4237              
4238              
4239             sub G1_223 {
4240 0     0 1   my ($self, $value, $index) = @_;
4241              
4242 0           my $rc = '';
4243              
4244 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 223, $value, $index, 'SourceElementsopt', 'SourceElements')) {
  0            
  0            
4245 0 0         if ($index == 0) {
4246             }
4247             }
4248              
4249 0           return $rc;
4250             }
4251              
4252              
4253              
4254             sub G1_224 {
4255 0     0 1   my ($self, $value, $index) = @_;
4256              
4257 0           my $rc = '';
4258              
4259 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 224, $value, $index, 'SourceElementsopt', )) {
  0            
  0            
4260             }
4261              
4262 0           return $rc;
4263             }
4264              
4265              
4266              
4267             sub G1_225 {
4268 0     0 1   my ($self, $value, $index) = @_;
4269              
4270 0           my $rc = '';
4271              
4272 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 225, $value, $index, 'FunctionBody', 'SourceElementsopt')) {
  0            
  0            
4273 0 0         if ($index == 0) {
4274             }
4275             }
4276              
4277 0           return $rc;
4278             }
4279              
4280              
4281              
4282             sub G1_226 {
4283 0     0 1   my ($self, $value, $index) = @_;
4284              
4285 0           my $rc = '';
4286              
4287 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 226, $value, $index, 'Program', 'SourceElementsopt')) {
  0            
  0            
4288 0 0         if ($index == 0) {
4289             }
4290             }
4291              
4292 0           return $rc;
4293             }
4294              
4295              
4296              
4297             sub G1_227 {
4298 0     0 1   my ($self, $value, $index) = @_;
4299              
4300 0           my $rc = '';
4301              
4302 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 227, $value, $index, 'SourceElements', 'SourceElement')) {
  0            
  0            
4303 0 0         if ($index == 0) {
4304             }
4305             }
4306              
4307 0           return $rc;
4308             }
4309              
4310              
4311              
4312             sub G1_228 {
4313 0     0 1   my ($self, $value, $index) = @_;
4314              
4315 0           my $rc = '';
4316              
4317 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 228, $value, $index, 'SourceElements', 'SourceElements', 'SourceElement')) {
  0            
  0            
4318 0 0         if ($index == 0) {
    0          
4319             }
4320             elsif ($index == 1) {
4321             }
4322             }
4323              
4324 0           return $rc;
4325             }
4326              
4327              
4328              
4329             sub G1_229 {
4330 0     0 1   my ($self, $value, $index) = @_;
4331              
4332 0           my $rc = '';
4333              
4334 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 229, $value, $index, 'SourceElement', 'Statement')) {
  0            
  0            
4335 0 0         if ($index == 0) {
4336             }
4337             }
4338              
4339 0           return $rc;
4340             }
4341              
4342              
4343              
4344             sub G1_230 {
4345 0     0 1   my ($self, $value, $index) = @_;
4346              
4347 0           my $rc = '';
4348              
4349 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 230, $value, $index, 'SourceElement', 'FunctionDeclaration')) {
  0            
  0            
4350 0 0         if ($index == 0) {
4351             }
4352             }
4353              
4354 0           return $rc;
4355             }
4356              
4357              
4358              
4359             sub G1_231 {
4360 0     0 1   my ($self, $value, $index) = @_;
4361              
4362 0           my $rc = '';
4363              
4364 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 231, $value, $index, 'NullLiteral', 'NULL')) {
  0            
  0            
4365 0 0         if ($index == 0) {
4366 0           $rc = $self->lexeme('NULL', 231, $value, 0, 'NullLiteral', 'NULL');
4367             }
4368             }
4369              
4370 0           return $rc;
4371             }
4372              
4373              
4374              
4375             sub G1_232 {
4376 0     0 1   my ($self, $value, $index) = @_;
4377              
4378 0           my $rc = '';
4379              
4380 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 232, $value, $index, 'BooleanLiteral', 'TRUE')) {
  0            
  0            
4381 0 0         if ($index == 0) {
4382 0           $rc = $self->lexeme('TRUE', 232, $value, 0, 'BooleanLiteral', 'TRUE');
4383             }
4384             }
4385              
4386 0           return $rc;
4387             }
4388              
4389              
4390              
4391             sub G1_233 {
4392 0     0 1   my ($self, $value, $index) = @_;
4393              
4394 0           my $rc = '';
4395              
4396 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 233, $value, $index, 'BooleanLiteral', 'FALSE')) {
  0            
  0            
4397 0 0         if ($index == 0) {
4398 0           $rc = $self->lexeme('FALSE', 233, $value, 0, 'BooleanLiteral', 'FALSE');
4399             }
4400             }
4401              
4402 0           return $rc;
4403             }
4404              
4405              
4406              
4407             sub G1_234 {
4408 0     0 1   my ($self, $value, $index) = @_;
4409              
4410 0           my $rc = '';
4411              
4412 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 234, $value, $index, 'StringLiteral', 'STRINGLITERAL')) {
  0            
  0            
4413 0 0         if ($index == 0) {
4414 0           $rc = $self->lexeme('STRINGLITERAL', 234, $value, 0, 'StringLiteral', 'STRINGLITERAL');
4415             }
4416             }
4417              
4418 0           return $rc;
4419             }
4420              
4421              
4422              
4423             sub G1_235 {
4424 0     0 1   my ($self, $value, $index) = @_;
4425              
4426 0           my $rc = '';
4427              
4428 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 235, $value, $index, 'RegularExpressionLiteral', 'REGULAREXPRESSIONLITERAL')) {
  0            
  0            
4429 0 0         if ($index == 0) {
4430 0           $rc = $self->lexeme('REGULAREXPRESSIONLITERAL', 235, $value, 0, 'RegularExpressionLiteral', 'REGULAREXPRESSIONLITERAL');
4431             }
4432             }
4433              
4434 0           return $rc;
4435             }
4436              
4437              
4438              
4439             sub G1_236 {
4440 0     0 1   my ($self, $value, $index) = @_;
4441              
4442 0           my $rc = '';
4443              
4444 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 236, $value, $index, 'NumericLiteral', 'DecimalLiteral')) {
  0            
  0            
4445 0 0         if ($index == 0) {
4446             }
4447             }
4448              
4449 0           return $rc;
4450             }
4451              
4452              
4453              
4454             sub G1_237 {
4455 0     0 1   my ($self, $value, $index) = @_;
4456              
4457 0           my $rc = '';
4458              
4459 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 237, $value, $index, 'NumericLiteral', 'HexIntegerLiteral')) {
  0            
  0            
4460 0 0         if ($index == 0) {
4461             }
4462             }
4463              
4464 0           return $rc;
4465             }
4466              
4467              
4468              
4469             sub G1_238 {
4470 0     0 1   my ($self, $value, $index) = @_;
4471              
4472 0           my $rc = '';
4473              
4474 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 238, $value, $index, 'NumericLiteral', 'OctalIntegerLiteral')) {
  0            
  0            
4475 0 0         if ($index == 0) {
4476             }
4477             }
4478              
4479 0           return $rc;
4480             }
4481              
4482              
4483              
4484             sub G1_239 {
4485 0     0 1   my ($self, $value, $index) = @_;
4486              
4487 0           my $rc = '';
4488              
4489 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 239, $value, $index, 'DecimalLiteral', 'DECIMALLITERAL')) {
  0            
  0            
4490 0 0         if ($index == 0) {
4491 0           $rc = $self->lexeme('DECIMALLITERAL', 239, $value, 0, 'DecimalLiteral', 'DECIMALLITERAL');
4492             }
4493             }
4494              
4495 0           return $rc;
4496             }
4497              
4498              
4499              
4500             sub G1_240 {
4501 0     0 1   my ($self, $value, $index) = @_;
4502              
4503 0           my $rc = '';
4504              
4505 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 240, $value, $index, 'HexIntegerLiteral', 'HEXINTEGERLITERAL')) {
  0            
  0            
4506 0 0         if ($index == 0) {
4507 0           $rc = $self->lexeme('HEXINTEGERLITERAL', 240, $value, 0, 'HexIntegerLiteral', 'HEXINTEGERLITERAL');
4508             }
4509             }
4510              
4511 0           return $rc;
4512             }
4513              
4514              
4515              
4516             sub G1_241 {
4517 0     0 1   my ($self, $value, $index) = @_;
4518              
4519 0           my $rc = '';
4520              
4521 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 241, $value, $index, 'OctalIntegerLiteral', 'OCTALINTEGERLITERAL')) {
  0            
  0            
4522 0 0         if ($index == 0) {
4523 0           $rc = $self->lexeme('OCTALINTEGERLITERAL', 241, $value, 0, 'OctalIntegerLiteral', 'OCTALINTEGERLITERAL');
4524             }
4525             }
4526              
4527 0           return $rc;
4528             }
4529              
4530              
4531              
4532             sub G1_242 {
4533 0     0 1   my ($self, $value, $index) = @_;
4534              
4535 0           my $rc = '';
4536              
4537 0 0         if (&{$self->{_g1Callback}}(@{$self->{_g1CallbackArgs}}, \$rc, 242, $value, $index, '[:start]', 'Program')) {
  0            
  0            
4538 0 0         if ($index == 0) {
4539             }
4540             }
4541              
4542 0           return $rc;
4543             }
4544              
4545             1;
4546              
4547             __END__