KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > jexl > parser > Parser


1 /*
2  * Copyright 2002-2006 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */

16 /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
17 package org.apache.commons.jexl.parser;
18
19 import java.io.Reader JavaDoc;
20
21 public class Parser/* @bgen(jjtree) */implements ParserTreeConstants, ParserConstants { /* @bgen(jjtree) */
22     protected JJTParserState jjtree = new JJTParserState();
23
24     public SimpleNode parse(Reader JavaDoc reader) throws Exception JavaDoc {
25         ReInit(reader);
26
27         /*
28          * lets do the 'Unique Init' in here to be safe - it's a pain to
29          * remember
30          */

31
32         SimpleNode tree = JexlScript();
33         return tree;
34     }
35
36     /*
37      * Program structuring syntax follows.
38      */

39     public final SimpleNode JexlScript() throws ParseException {
40         /* @bgen(jjtree) JexlScript */
41         ASTJexlScript jjtn000 = new ASTJexlScript(this, JJTJEXLSCRIPT);
42         boolean jjtc000 = true;
43         jjtree.openNodeScope(jjtn000);
44         String JavaDoc name;
45         try {
46             label_1: while (true) {
47                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
48                     case INTEGER_LITERAL:
49                     case FLOAT_LITERAL:
50                     case 9:
51                     case 11:
52                     case 12:
53                     case 14:
54                     case 36:
55                     case 42:
56                     case 43:
57                     case 44:
58                     case 45:
59                     case 46:
60                     case 47:
61                     case 48:
62                     case 49:
63                     case 51:
64                     case 52:
65                     case IDENTIFIER:
66                     case STRING_LITERAL:
67                         ;
68                         break;
69                     default:
70                         jj_la1[0] = jj_gen;
71                         break label_1;
72                 }
73                 Statement();
74             }
75             jj_consume_token(0);
76             jjtree.closeNodeScope(jjtn000, true);
77             jjtc000 = false;
78             {
79                 if (true)
80                     return jjtn000;
81             }
82         } catch (Throwable JavaDoc jjte000) {
83             if (jjtc000) {
84                 jjtree.clearNodeScope(jjtn000);
85                 jjtc000 = false;
86             } else {
87                 jjtree.popNode();
88             }
89             if (jjte000 instanceof RuntimeException JavaDoc) {
90                 {
91                     if (true)
92                         throw (RuntimeException JavaDoc) jjte000;
93                 }
94             }
95             if (jjte000 instanceof ParseException) {
96                 {
97                     if (true)
98                         throw (ParseException) jjte000;
99                 }
100             }
101             {
102                 if (true)
103                     throw (Error JavaDoc) jjte000;
104             }
105         } finally {
106             if (jjtc000) {
107                 jjtree.closeNodeScope(jjtn000, true);
108             }
109         }
110         throw new Error JavaDoc("Missing return statement in function");
111     }
112
113     final public void Block() throws ParseException {
114         /* @bgen(jjtree) Block */
115         ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
116         boolean jjtc000 = true;
117         jjtree.openNodeScope(jjtn000);
118         try {
119             jj_consume_token(9);
120             label_2: while (true) {
121                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
122                     case INTEGER_LITERAL:
123                     case FLOAT_LITERAL:
124                     case 9:
125                     case 11:
126                     case 12:
127                     case 14:
128                     case 36:
129                     case 42:
130                     case 43:
131                     case 44:
132                     case 45:
133                     case 46:
134                     case 47:
135                     case 48:
136                     case 49:
137                     case 51:
138                     case 52:
139                     case IDENTIFIER:
140                     case STRING_LITERAL:
141                         ;
142                         break;
143                     default:
144                         jj_la1[1] = jj_gen;
145                         break label_2;
146                 }
147                 Statement();
148             }
149             jj_consume_token(10);
150         } catch (Throwable JavaDoc jjte000) {
151             if (jjtc000) {
152                 jjtree.clearNodeScope(jjtn000);
153                 jjtc000 = false;
154             } else {
155                 jjtree.popNode();
156             }
157             if (jjte000 instanceof RuntimeException JavaDoc) {
158                 {
159                     if (true)
160                         throw (RuntimeException JavaDoc) jjte000;
161                 }
162             }
163             if (jjte000 instanceof ParseException) {
164                 {
165                     if (true)
166                         throw (ParseException) jjte000;
167                 }
168             }
169             {
170                 if (true)
171                     throw (Error JavaDoc) jjte000;
172             }
173         } finally {
174             if (jjtc000) {
175                 jjtree.closeNodeScope(jjtn000, true);
176             }
177         }
178     }
179
180     final public void EmptyFunction() throws ParseException {
181         /* @bgen(jjtree) EmptyFunction */
182         ASTEmptyFunction jjtn000 = new ASTEmptyFunction(this, JJTEMPTYFUNCTION);
183         boolean jjtc000 = true;
184         jjtree.openNodeScope(jjtn000);
185         try {
186             jj_consume_token(11);
187             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
188                 case IDENTIFIER:
189                     Reference();
190                     break;
191                 case 12:
192                     jj_consume_token(12);
193                     Reference();
194                     jj_consume_token(13);
195                     break;
196                 default:
197                     jj_la1[2] = jj_gen;
198                     jj_consume_token(-1);
199                     throw new ParseException();
200             }
201         } catch (Throwable JavaDoc jjte000) {
202             if (jjtc000) {
203                 jjtree.clearNodeScope(jjtn000);
204                 jjtc000 = false;
205             } else {
206                 jjtree.popNode();
207             }
208             if (jjte000 instanceof RuntimeException JavaDoc) {
209                 {
210                     if (true)
211                         throw (RuntimeException JavaDoc) jjte000;
212                 }
213             }
214             if (jjte000 instanceof ParseException) {
215                 {
216                     if (true)
217                         throw (ParseException) jjte000;
218                 }
219             }
220             {
221                 if (true)
222                     throw (Error JavaDoc) jjte000;
223             }
224         } finally {
225             if (jjtc000) {
226                 jjtree.closeNodeScope(jjtn000, true);
227             }
228         }
229     }
230
231     final public void SizeFunction() throws ParseException {
232         /* @bgen(jjtree) SizeFunction */
233         ASTSizeFunction jjtn000 = new ASTSizeFunction(this, JJTSIZEFUNCTION);
234         boolean jjtc000 = true;
235         jjtree.openNodeScope(jjtn000);
236         try {
237             jj_consume_token(14);
238             jj_consume_token(12);
239             Reference();
240             jj_consume_token(13);
241         } catch (Throwable JavaDoc jjte000) {
242             if (jjtc000) {
243                 jjtree.clearNodeScope(jjtn000);
244                 jjtc000 = false;
245             } else {
246                 jjtree.popNode();
247             }
248             if (jjte000 instanceof RuntimeException JavaDoc) {
249                 {
250                     if (true)
251                         throw (RuntimeException JavaDoc) jjte000;
252                 }
253             }
254             if (jjte000 instanceof ParseException) {
255                 {
256                     if (true)
257                         throw (ParseException) jjte000;
258                 }
259             }
260             {
261                 if (true)
262                     throw (Error JavaDoc) jjte000;
263             }
264         } finally {
265             if (jjtc000) {
266                 jjtree.closeNodeScope(jjtn000, true);
267             }
268         }
269     }
270
271     final public void Identifier() throws ParseException {
272         /* @bgen(jjtree) Identifier */
273         ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER);
274         boolean jjtc000 = true;
275         jjtree.openNodeScope(jjtn000);
276         Token t;
277         try {
278             t = jj_consume_token(IDENTIFIER);
279             jjtree.closeNodeScope(jjtn000, true);
280             jjtc000 = false;
281             jjtn000.val = t.image;
282         } finally {
283             if (jjtc000) {
284                 jjtree.closeNodeScope(jjtn000, true);
285             }
286         }
287     }
288
289     /*
290      * Expression syntax follows.
291      */

292     final public void Expression() throws ParseException {
293         /* @bgen(jjtree) Expression */
294         ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
295         boolean jjtc000 = true;
296         jjtree.openNodeScope(jjtn000);
297         try {
298             if (jj_2_1(2147483647)) {
299                 Assignment();
300             } else {
301                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
302                     case INTEGER_LITERAL:
303                     case FLOAT_LITERAL:
304                     case 11:
305                     case 12:
306                     case 14:
307                     case 36:
308                     case 42:
309                     case 43:
310                     case 44:
311                     case 45:
312                     case 46:
313                     case 47:
314                     case IDENTIFIER:
315                     case STRING_LITERAL:
316                         ConditionalOrExpression();
317                         break;
318                     default:
319                         jj_la1[3] = jj_gen;
320                         jj_consume_token(-1);
321                         throw new ParseException();
322                 }
323             }
324         } catch (Throwable JavaDoc jjte000) {
325             if (jjtc000) {
326                 jjtree.clearNodeScope(jjtn000);
327                 jjtc000 = false;
328             } else {
329                 jjtree.popNode();
330             }
331             if (jjte000 instanceof RuntimeException JavaDoc) {
332                 {
333                     if (true)
334                         throw (RuntimeException JavaDoc) jjte000;
335                 }
336             }
337             if (jjte000 instanceof ParseException) {
338                 {
339                     if (true)
340                         throw (ParseException) jjte000;
341                 }
342             }
343             {
344                 if (true)
345                     throw (Error JavaDoc) jjte000;
346             }
347         } finally {
348             if (jjtc000) {
349                 jjtree.closeNodeScope(jjtn000, true);
350             }
351         }
352     }
353
354     final public void Assignment() throws ParseException {
355         /* @bgen(jjtree) #Assignment( 2) */
356         ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
357         boolean jjtc000 = true;
358         jjtree.openNodeScope(jjtn000);
359         try {
360             PrimaryExpression();
361             jj_consume_token(15);
362             Expression();
363         } catch (Throwable JavaDoc jjte000) {
364             if (jjtc000) {
365                 jjtree.clearNodeScope(jjtn000);
366                 jjtc000 = false;
367             } else {
368                 jjtree.popNode();
369             }
370             if (jjte000 instanceof RuntimeException JavaDoc) {
371                 {
372                     if (true)
373                         throw (RuntimeException JavaDoc) jjte000;
374                 }
375             }
376             if (jjte000 instanceof ParseException) {
377                 {
378                     if (true)
379                         throw (ParseException) jjte000;
380                 }
381             }
382             {
383                 if (true)
384                     throw (Error JavaDoc) jjte000;
385             }
386         } finally {
387             if (jjtc000) {
388                 jjtree.closeNodeScope(jjtn000, 2);
389             }
390         }
391     }
392
393     final public void ConditionalOrExpression() throws ParseException {
394         ConditionalAndExpression();
395         label_3: while (true) {
396             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
397                 case 16:
398                 case 17:
399                     ;
400                     break;
401                 default:
402                     jj_la1[4] = jj_gen;
403                     break label_3;
404             }
405             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
406                 case 16:
407                     jj_consume_token(16);
408                     ASTOrNode jjtn001 = new ASTOrNode(this, JJTORNODE);
409                     boolean jjtc001 = true;
410                     jjtree.openNodeScope(jjtn001);
411                     try {
412                         ConditionalAndExpression();
413                     } catch (Throwable JavaDoc jjte001) {
414                         if (jjtc001) {
415                             jjtree.clearNodeScope(jjtn001);
416                             jjtc001 = false;
417                         } else {
418                             jjtree.popNode();
419                         }
420                         if (jjte001 instanceof RuntimeException JavaDoc) {
421                             {
422                                 if (true)
423                                     throw (RuntimeException JavaDoc) jjte001;
424                             }
425                         }
426                         if (jjte001 instanceof ParseException) {
427                             {
428                                 if (true)
429                                     throw (ParseException) jjte001;
430                             }
431                         }
432                         {
433                             if (true)
434                                 throw (Error JavaDoc) jjte001;
435                         }
436                     } finally {
437                         if (jjtc001) {
438                             jjtree.closeNodeScope(jjtn001, 2);
439                         }
440                     }
441                     break;
442                 case 17:
443                     jj_consume_token(17);
444                     ASTOrNode jjtn002 = new ASTOrNode(this, JJTORNODE);
445                     boolean jjtc002 = true;
446                     jjtree.openNodeScope(jjtn002);
447                     try {
448                         ConditionalAndExpression();
449                     } catch (Throwable JavaDoc jjte002) {
450                         if (jjtc002) {
451                             jjtree.clearNodeScope(jjtn002);
452                             jjtc002 = false;
453                         } else {
454                             jjtree.popNode();
455                         }
456                         if (jjte002 instanceof RuntimeException JavaDoc) {
457                             {
458                                 if (true)
459                                     throw (RuntimeException JavaDoc) jjte002;
460                             }
461                         }
462                         if (jjte002 instanceof ParseException) {
463                             {
464                                 if (true)
465                                     throw (ParseException) jjte002;
466                             }
467                         }
468                         {
469                             if (true)
470                                 throw (Error JavaDoc) jjte002;
471                         }
472                     } finally {
473                         if (jjtc002) {
474                             jjtree.closeNodeScope(jjtn002, 2);
475                         }
476                     }
477                     break;
478                 default:
479                     jj_la1[5] = jj_gen;
480                     jj_consume_token(-1);
481                     throw new ParseException();
482             }
483         }
484     }
485
486     final public void ConditionalAndExpression() throws ParseException {
487         InclusiveOrExpression();
488         label_4: while (true) {
489             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
490                 case 18:
491                 case 19:
492                     ;
493                     break;
494                 default:
495                     jj_la1[6] = jj_gen;
496                     break label_4;
497             }
498             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
499                 case 18:
500                     jj_consume_token(18);
501                     ASTAndNode jjtn001 = new ASTAndNode(this, JJTANDNODE);
502                     boolean jjtc001 = true;
503                     jjtree.openNodeScope(jjtn001);
504                     try {
505                         InclusiveOrExpression();
506                     } catch (Throwable JavaDoc jjte001) {
507                         if (jjtc001) {
508                             jjtree.clearNodeScope(jjtn001);
509                             jjtc001 = false;
510                         } else {
511                             jjtree.popNode();
512                         }
513                         if (jjte001 instanceof RuntimeException JavaDoc) {
514                             {
515                                 if (true)
516                                     throw (RuntimeException JavaDoc) jjte001;
517                             }
518                         }
519                         if (jjte001 instanceof ParseException) {
520                             {
521                                 if (true)
522                                     throw (ParseException) jjte001;
523                             }
524                         }
525                         {
526                             if (true)
527                                 throw (Error JavaDoc) jjte001;
528                         }
529                     } finally {
530                         if (jjtc001) {
531                             jjtree.closeNodeScope(jjtn001, 2);
532                         }
533                     }
534                     break;
535                 case 19:
536                     jj_consume_token(19);
537                     ASTAndNode jjtn002 = new ASTAndNode(this, JJTANDNODE);
538                     boolean jjtc002 = true;
539                     jjtree.openNodeScope(jjtn002);
540                     try {
541                         InclusiveOrExpression();
542                     } catch (Throwable JavaDoc jjte002) {
543                         if (jjtc002) {
544                             jjtree.clearNodeScope(jjtn002);
545                             jjtc002 = false;
546                         } else {
547                             jjtree.popNode();
548                         }
549                         if (jjte002 instanceof RuntimeException JavaDoc) {
550                             {
551                                 if (true)
552                                     throw (RuntimeException JavaDoc) jjte002;
553                             }
554                         }
555                         if (jjte002 instanceof ParseException) {
556                             {
557                                 if (true)
558                                     throw (ParseException) jjte002;
559                             }
560                         }
561                         {
562                             if (true)
563                                 throw (Error JavaDoc) jjte002;
564                         }
565                     } finally {
566                         if (jjtc002) {
567                             jjtree.closeNodeScope(jjtn002, 2);
568                         }
569                     }
570                     break;
571                 default:
572                     jj_la1[7] = jj_gen;
573                     jj_consume_token(-1);
574                     throw new ParseException();
575             }
576         }
577     }
578
579     final public void InclusiveOrExpression() throws ParseException {
580         ExclusiveOrExpression();
581         label_5: while (true) {
582             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
583                 case 20:
584                     ;
585                     break;
586                 default:
587                     jj_la1[8] = jj_gen;
588                     break label_5;
589             }
590             jj_consume_token(20);
591             ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(this, JJTBITWISEORNODE);
592             boolean jjtc001 = true;
593             jjtree.openNodeScope(jjtn001);
594             try {
595                 ExclusiveOrExpression();
596             } catch (Throwable JavaDoc jjte001) {
597                 if (jjtc001) {
598                     jjtree.clearNodeScope(jjtn001);
599                     jjtc001 = false;
600                 } else {
601                     jjtree.popNode();
602                 }
603                 if (jjte001 instanceof RuntimeException JavaDoc) {
604                     {
605                         if (true)
606                             throw (RuntimeException JavaDoc) jjte001;
607                     }
608                 }
609                 if (jjte001 instanceof ParseException) {
610                     {
611                         if (true)
612                             throw (ParseException) jjte001;
613                     }
614                 }
615                 {
616                     if (true)
617                         throw (Error JavaDoc) jjte001;
618                 }
619             } finally {
620                 if (jjtc001) {
621                     jjtree.closeNodeScope(jjtn001, 2);
622                 }
623             }
624         }
625     }
626
627     final public void ExclusiveOrExpression() throws ParseException {
628         AndExpression();
629         label_6: while (true) {
630             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
631                 case 21:
632                     ;
633                     break;
634                 default:
635                     jj_la1[9] = jj_gen;
636                     break label_6;
637             }
638             jj_consume_token(21);
639             ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(this, JJTBITWISEXORNODE);
640             boolean jjtc001 = true;
641             jjtree.openNodeScope(jjtn001);
642             try {
643                 AndExpression();
644             } catch (Throwable JavaDoc jjte001) {
645                 if (jjtc001) {
646                     jjtree.clearNodeScope(jjtn001);
647                     jjtc001 = false;
648                 } else {
649                     jjtree.popNode();
650                 }
651                 if (jjte001 instanceof RuntimeException JavaDoc) {
652                     {
653                         if (true)
654                             throw (RuntimeException JavaDoc) jjte001;
655                     }
656                 }
657                 if (jjte001 instanceof ParseException) {
658                     {
659                         if (true)
660                             throw (ParseException) jjte001;
661                     }
662                 }
663                 {
664                     if (true)
665                         throw (Error JavaDoc) jjte001;
666                 }
667             } finally {
668                 if (jjtc001) {
669                     jjtree.closeNodeScope(jjtn001, 2);
670                 }
671             }
672         }
673     }
674
675     final public void AndExpression() throws ParseException {
676         EqualityExpression();
677         label_7: while (true) {
678             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
679                 case 22:
680                     ;
681                     break;
682                 default:
683                     jj_la1[10] = jj_gen;
684                     break label_7;
685             }
686             jj_consume_token(22);
687             ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(this, JJTBITWISEANDNODE);
688             boolean jjtc001 = true;
689             jjtree.openNodeScope(jjtn001);
690             try {
691                 EqualityExpression();
692             } catch (Throwable JavaDoc jjte001) {
693                 if (jjtc001) {
694                     jjtree.clearNodeScope(jjtn001);
695                     jjtc001 = false;
696                 } else {
697                     jjtree.popNode();
698                 }
699                 if (jjte001 instanceof RuntimeException JavaDoc) {
700                     {
701                         if (true)
702                             throw (RuntimeException JavaDoc) jjte001;
703                     }
704                 }
705                 if (jjte001 instanceof ParseException) {
706                     {
707                         if (true)
708                             throw (ParseException) jjte001;
709                     }
710                 }
711                 {
712                     if (true)
713                         throw (Error JavaDoc) jjte001;
714                 }
715             } finally {
716                 if (jjtc001) {
717                     jjtree.closeNodeScope(jjtn001, 2);
718                 }
719             }
720         }
721     }
722
723     final public void EqualityExpression() throws ParseException {
724         RelationalExpression();
725         label_8: while (true) {
726             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
727                 case 23:
728                 case 24:
729                 case 25:
730                 case 26:
731                     ;
732                     break;
733                 default:
734                     jj_la1[11] = jj_gen;
735                     break label_8;
736             }
737             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
738                 case 23:
739                     jj_consume_token(23);
740                     ASTEQNode jjtn001 = new ASTEQNode(this, JJTEQNODE);
741                     boolean jjtc001 = true;
742                     jjtree.openNodeScope(jjtn001);
743                     try {
744                         RelationalExpression();
745                     } catch (Throwable JavaDoc jjte001) {
746                         if (jjtc001) {
747                             jjtree.clearNodeScope(jjtn001);
748                             jjtc001 = false;
749                         } else {
750                             jjtree.popNode();
751                         }
752                         if (jjte001 instanceof RuntimeException JavaDoc) {
753                             {
754                                 if (true)
755                                     throw (RuntimeException JavaDoc) jjte001;
756                             }
757                         }
758                         if (jjte001 instanceof ParseException) {
759                             {
760                                 if (true)
761                                     throw (ParseException) jjte001;
762                             }
763                         }
764                         {
765                             if (true)
766                                 throw (Error JavaDoc) jjte001;
767                         }
768                     } finally {
769                         if (jjtc001) {
770                             jjtree.closeNodeScope(jjtn001, 2);
771                         }
772                     }
773                     break;
774                 case 24:
775                     jj_consume_token(24);
776                     ASTEQNode jjtn002 = new ASTEQNode(this, JJTEQNODE);
777                     boolean jjtc002 = true;
778                     jjtree.openNodeScope(jjtn002);
779                     try {
780                         RelationalExpression();
781                     } catch (Throwable JavaDoc jjte002) {
782                         if (jjtc002) {
783                             jjtree.clearNodeScope(jjtn002);
784                             jjtc002 = false;
785                         } else {
786                             jjtree.popNode();
787                         }
788                         if (jjte002 instanceof RuntimeException JavaDoc) {
789                             {
790                                 if (true)
791                                     throw (RuntimeException JavaDoc) jjte002;
792                             }
793                         }
794                         if (jjte002 instanceof ParseException) {
795                             {
796                                 if (true)
797                                     throw (ParseException) jjte002;
798                             }
799                         }
800                         {
801                             if (true)
802                                 throw (Error JavaDoc) jjte002;
803                         }
804                     } finally {
805                         if (jjtc002) {
806                             jjtree.closeNodeScope(jjtn002, 2);
807                         }
808                     }
809                     break;
810                 case 25:
811                     jj_consume_token(25);
812                     ASTNENode jjtn003 = new ASTNENode(this, JJTNENODE);
813                     boolean jjtc003 = true;
814                     jjtree.openNodeScope(jjtn003);
815                     try {
816                         RelationalExpression();
817                     } catch (Throwable JavaDoc jjte003) {
818                         if (jjtc003) {
819                             jjtree.clearNodeScope(jjtn003);
820                             jjtc003 = false;
821                         } else {
822                             jjtree.popNode();
823                         }
824                         if (jjte003 instanceof RuntimeException JavaDoc) {
825                             {
826                                 if (true)
827                                     throw (RuntimeException JavaDoc) jjte003;
828                             }
829                         }
830                         if (jjte003 instanceof ParseException) {
831                             {
832                                 if (true)
833                                     throw (ParseException) jjte003;
834                             }
835                         }
836                         {
837                             if (true)
838                                 throw (Error JavaDoc) jjte003;
839                         }
840                     } finally {
841                         if (jjtc003) {
842                             jjtree.closeNodeScope(jjtn003, 2);
843                         }
844                     }
845                     break;
846                 case 26:
847                     jj_consume_token(26);
848                     ASTNENode jjtn004 = new ASTNENode(this, JJTNENODE);
849                     boolean jjtc004 = true;
850                     jjtree.openNodeScope(jjtn004);
851                     try {
852                         RelationalExpression();
853                     } catch (Throwable JavaDoc jjte004) {
854                         if (jjtc004) {
855                             jjtree.clearNodeScope(jjtn004);
856                             jjtc004 = false;
857                         } else {
858                             jjtree.popNode();
859                         }
860                         if (jjte004 instanceof RuntimeException JavaDoc) {
861                             {
862                                 if (true)
863                                     throw (RuntimeException JavaDoc) jjte004;
864                             }
865                         }
866                         if (jjte004 instanceof ParseException) {
867                             {
868                                 if (true)
869                                     throw (ParseException) jjte004;
870                             }
871                         }
872                         {
873                             if (true)
874                                 throw (Error JavaDoc) jjte004;
875                         }
876                     } finally {
877                         if (jjtc004) {
878                             jjtree.closeNodeScope(jjtn004, 2);
879                         }
880                     }
881                     break;
882                 default:
883                     jj_la1[12] = jj_gen;
884                     jj_consume_token(-1);
885                     throw new ParseException();
886             }
887         }
888     }
889
890     final public void RelationalExpression() throws ParseException {
891         AdditiveExpression();
892         label_9: while (true) {
893             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
894                 case 27:
895                 case 28:
896                 case 29:
897                 case 30:
898                 case 31:
899                 case 32:
900                 case 33:
901                 case 34:
902                     ;
903                     break;
904                 default:
905                     jj_la1[13] = jj_gen;
906                     break label_9;
907             }
908             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
909                 case 27:
910                     jj_consume_token(27);
911                     ASTLTNode jjtn001 = new ASTLTNode(this, JJTLTNODE);
912                     boolean jjtc001 = true;
913                     jjtree.openNodeScope(jjtn001);
914                     try {
915                         AdditiveExpression();
916                     } catch (Throwable JavaDoc jjte001) {
917                         if (jjtc001) {
918                             jjtree.clearNodeScope(jjtn001);
919                             jjtc001 = false;
920                         } else {
921                             jjtree.popNode();
922                         }
923                         if (jjte001 instanceof RuntimeException JavaDoc) {
924                             {
925                                 if (true)
926                                     throw (RuntimeException JavaDoc) jjte001;
927                             }
928                         }
929                         if (jjte001 instanceof ParseException) {
930                             {
931                                 if (true)
932                                     throw (ParseException) jjte001;
933                             }
934                         }
935                         {
936                             if (true)
937                                 throw (Error JavaDoc) jjte001;
938                         }
939                     } finally {
940                         if (jjtc001) {
941                             jjtree.closeNodeScope(jjtn001, 2);
942                         }
943                     }
944                     break;
945                 case 28:
946                     jj_consume_token(28);
947                     ASTLTNode jjtn002 = new ASTLTNode(this, JJTLTNODE);
948                     boolean jjtc002 = true;
949                     jjtree.openNodeScope(jjtn002);
950                     try {
951                         AdditiveExpression();
952                     } catch (Throwable JavaDoc jjte002) {
953                         if (jjtc002) {
954                             jjtree.clearNodeScope(jjtn002);
955                             jjtc002 = false;
956                         } else {
957                             jjtree.popNode();
958                         }
959                         if (jjte002 instanceof RuntimeException JavaDoc) {
960                             {
961                                 if (true)
962                                     throw (RuntimeException JavaDoc) jjte002;
963                             }
964                         }
965                         if (jjte002 instanceof ParseException) {
966                             {
967                                 if (true)
968                                     throw (ParseException) jjte002;
969                             }
970                         }
971                         {
972                             if (true)
973                                 throw (Error JavaDoc) jjte002;
974                         }
975                     } finally {
976                         if (jjtc002) {
977                             jjtree.closeNodeScope(jjtn002, 2);
978                         }
979                     }
980                     break;
981                 case 29:
982                     jj_consume_token(29);
983                     ASTGTNode jjtn003 = new ASTGTNode(this, JJTGTNODE);
984                     boolean jjtc003 = true;
985                     jjtree.openNodeScope(jjtn003);
986                     try {
987                         AdditiveExpression();
988                     } catch (Throwable JavaDoc jjte003) {
989                         if (jjtc003) {
990                             jjtree.clearNodeScope(jjtn003);
991                             jjtc003 = false;
992                         } else {
993                             jjtree.popNode();
994                         }
995                         if (jjte003 instanceof RuntimeException JavaDoc) {
996                             {
997                                 if (true)
998                                     throw (RuntimeException JavaDoc) jjte003;
999                             }
1000                        }
1001                        if (jjte003 instanceof ParseException) {
1002                            {
1003                                if (true)
1004                                    throw (ParseException) jjte003;
1005                            }
1006                        }
1007                        {
1008                            if (true)
1009                                throw (Error JavaDoc) jjte003;
1010                        }
1011                    } finally {
1012                        if (jjtc003) {
1013                            jjtree.closeNodeScope(jjtn003, 2);
1014                        }
1015                    }
1016                    break;
1017                case 30:
1018                    jj_consume_token(30);
1019                    ASTGTNode jjtn004 = new ASTGTNode(this, JJTGTNODE);
1020                    boolean jjtc004 = true;
1021                    jjtree.openNodeScope(jjtn004);
1022                    try {
1023                        AdditiveExpression();
1024                    } catch (Throwable JavaDoc jjte004) {
1025                        if (jjtc004) {
1026                            jjtree.clearNodeScope(jjtn004);
1027                            jjtc004 = false;
1028                        } else {
1029                            jjtree.popNode();
1030                        }
1031                        if (jjte004 instanceof RuntimeException JavaDoc) {
1032                            {
1033                                if (true)
1034                                    throw (RuntimeException JavaDoc) jjte004;
1035                            }
1036                        }
1037                        if (jjte004 instanceof ParseException) {
1038                            {
1039                                if (true)
1040                                    throw (ParseException) jjte004;
1041                            }
1042                        }
1043                        {
1044                            if (true)
1045                                throw (Error JavaDoc) jjte004;
1046                        }
1047                    } finally {
1048                        if (jjtc004) {
1049                            jjtree.closeNodeScope(jjtn004, 2);
1050                        }
1051                    }
1052                    break;
1053                case 31:
1054                    jj_consume_token(31);
1055                    ASTLENode jjtn005 = new ASTLENode(this, JJTLENODE);
1056                    boolean jjtc005 = true;
1057                    jjtree.openNodeScope(jjtn005);
1058                    try {
1059                        AdditiveExpression();
1060                    } catch (Throwable JavaDoc jjte005) {
1061                        if (jjtc005) {
1062                            jjtree.clearNodeScope(jjtn005);
1063                            jjtc005 = false;
1064                        } else {
1065                            jjtree.popNode();
1066                        }
1067                        if (jjte005 instanceof RuntimeException JavaDoc) {
1068                            {
1069                                if (true)
1070                                    throw (RuntimeException JavaDoc) jjte005;
1071                            }
1072                        }
1073                        if (jjte005 instanceof ParseException) {
1074                            {
1075                                if (true)
1076                                    throw (ParseException) jjte005;
1077                            }
1078                        }
1079                        {
1080                            if (true)
1081                                throw (Error JavaDoc) jjte005;
1082                        }
1083                    } finally {
1084                        if (jjtc005) {
1085                            jjtree.closeNodeScope(jjtn005, 2);
1086                        }
1087                    }
1088                    break;
1089                case 32:
1090                    jj_consume_token(32);
1091                    ASTLENode jjtn006 = new ASTLENode(this, JJTLENODE);
1092                    boolean jjtc006 = true;
1093                    jjtree.openNodeScope(jjtn006);
1094                    try {
1095                        AdditiveExpression();
1096                    } catch (Throwable JavaDoc jjte006) {
1097                        if (jjtc006) {
1098                            jjtree.clearNodeScope(jjtn006);
1099                            jjtc006 = false;
1100                        } else {
1101                            jjtree.popNode();
1102                        }
1103                        if (jjte006 instanceof RuntimeException JavaDoc) {
1104                            {
1105                                if (true)
1106                                    throw (RuntimeException JavaDoc) jjte006;
1107                            }
1108                        }
1109                        if (jjte006 instanceof ParseException) {
1110                            {
1111                                if (true)
1112                                    throw (ParseException) jjte006;
1113                            }
1114                        }
1115                        {
1116                            if (true)
1117                                throw (Error JavaDoc) jjte006;
1118                        }
1119                    } finally {
1120                        if (jjtc006) {
1121                            jjtree.closeNodeScope(jjtn006, 2);
1122                        }
1123                    }
1124                    break;
1125                case 33:
1126                    jj_consume_token(33);
1127                    ASTGENode jjtn007 = new ASTGENode(this, JJTGENODE);
1128                    boolean jjtc007 = true;
1129                    jjtree.openNodeScope(jjtn007);
1130                    try {
1131                        AdditiveExpression();
1132                    } catch (Throwable JavaDoc jjte007) {
1133                        if (jjtc007) {
1134                            jjtree.clearNodeScope(jjtn007);
1135                            jjtc007 = false;
1136                        } else {
1137                            jjtree.popNode();
1138                        }
1139                        if (jjte007 instanceof RuntimeException JavaDoc) {
1140                            {
1141                                if (true)
1142                                    throw (RuntimeException JavaDoc) jjte007;
1143                            }
1144                        }
1145                        if (jjte007 instanceof ParseException) {
1146                            {
1147                                if (true)
1148                                    throw (ParseException) jjte007;
1149                            }
1150                        }
1151                        {
1152                            if (true)
1153                                throw (Error JavaDoc) jjte007;
1154                        }
1155                    } finally {
1156                        if (jjtc007) {
1157                            jjtree.closeNodeScope(jjtn007, 2);
1158                        }
1159                    }
1160                    break;
1161                case 34:
1162                    jj_consume_token(34);
1163                    ASTGENode jjtn008 = new ASTGENode(this, JJTGENODE);
1164                    boolean jjtc008 = true;
1165                    jjtree.openNodeScope(jjtn008);
1166                    try {
1167                        AdditiveExpression();
1168                    } catch (Throwable JavaDoc jjte008) {
1169                        if (jjtc008) {
1170                            jjtree.clearNodeScope(jjtn008);
1171                            jjtc008 = false;
1172                        } else {
1173                            jjtree.popNode();
1174                        }
1175                        if (jjte008 instanceof RuntimeException JavaDoc) {
1176                            {
1177                                if (true)
1178                                    throw (RuntimeException JavaDoc) jjte008;
1179                            }
1180                        }
1181                        if (jjte008 instanceof ParseException) {
1182                            {
1183                                if (true)
1184                                    throw (ParseException) jjte008;
1185                            }
1186                        }
1187                        {
1188                            if (true)
1189                                throw (Error JavaDoc) jjte008;
1190                        }
1191                    } finally {
1192                        if (jjtc008) {
1193                            jjtree.closeNodeScope(jjtn008, 2);
1194                        }
1195                    }
1196                    break;
1197                default:
1198                    jj_la1[14] = jj_gen;
1199                    jj_consume_token(-1);
1200                    throw new ParseException();
1201            }
1202        }
1203    }
1204
1205    final public void AdditiveExpression() throws ParseException {
1206        MultiplicativeExpression();
1207        label_10: while (true) {
1208            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1209                case 35:
1210                case 36:
1211                    ;
1212                    break;
1213                default:
1214                    jj_la1[15] = jj_gen;
1215                    break label_10;
1216            }
1217            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1218                case 35:
1219                    jj_consume_token(35);
1220                    ASTAddNode jjtn001 = new ASTAddNode(this, JJTADDNODE);
1221                    boolean jjtc001 = true;
1222                    jjtree.openNodeScope(jjtn001);
1223                    try {
1224                        MultiplicativeExpression();
1225                    } catch (Throwable JavaDoc jjte001) {
1226                        if (jjtc001) {
1227                            jjtree.clearNodeScope(jjtn001);
1228                            jjtc001 = false;
1229                        } else {
1230                            jjtree.popNode();
1231                        }
1232                        if (jjte001 instanceof RuntimeException JavaDoc) {
1233                            {
1234                                if (true)
1235                                    throw (RuntimeException JavaDoc) jjte001;
1236                            }
1237                        }
1238                        if (jjte001 instanceof ParseException) {
1239                            {
1240                                if (true)
1241                                    throw (ParseException) jjte001;
1242                            }
1243                        }
1244                        {
1245                            if (true)
1246                                throw (Error JavaDoc) jjte001;
1247                        }
1248                    } finally {
1249                        if (jjtc001) {
1250                            jjtree.closeNodeScope(jjtn001, 2);
1251                        }
1252                    }
1253                    break;
1254                case 36:
1255                    jj_consume_token(36);
1256                    ASTSubtractNode jjtn002 = new ASTSubtractNode(this, JJTSUBTRACTNODE);
1257                    boolean jjtc002 = true;
1258                    jjtree.openNodeScope(jjtn002);
1259                    try {
1260                        MultiplicativeExpression();
1261                    } catch (Throwable JavaDoc jjte002) {
1262                        if (jjtc002) {
1263                            jjtree.clearNodeScope(jjtn002);
1264                            jjtc002 = false;
1265                        } else {
1266                            jjtree.popNode();
1267                        }
1268                        if (jjte002 instanceof RuntimeException JavaDoc) {
1269                            {
1270                                if (true)
1271                                    throw (RuntimeException JavaDoc) jjte002;
1272                            }
1273                        }
1274                        if (jjte002 instanceof ParseException) {
1275                            {
1276                                if (true)
1277                                    throw (ParseException) jjte002;
1278                            }
1279                        }
1280                        {
1281                            if (true)
1282                                throw (Error JavaDoc) jjte002;
1283                        }
1284                    } finally {
1285                        if (jjtc002) {
1286                            jjtree.closeNodeScope(jjtn002, 2);
1287                        }
1288                    }
1289                    break;
1290                default:
1291                    jj_la1[16] = jj_gen;
1292                    jj_consume_token(-1);
1293                    throw new ParseException();
1294            }
1295        }
1296    }
1297
1298    final public void MultiplicativeExpression() throws ParseException {
1299        UnaryExpression();
1300        label_11: while (true) {
1301            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1302                case 37:
1303                case 38:
1304                case 39:
1305                case 40:
1306                case 41:
1307                    ;
1308                    break;
1309                default:
1310                    jj_la1[17] = jj_gen;
1311                    break label_11;
1312            }
1313            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1314                case 37:
1315                    jj_consume_token(37);
1316                    ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);
1317                    boolean jjtc001 = true;
1318                    jjtree.openNodeScope(jjtn001);
1319                    try {
1320                        UnaryExpression();
1321                    } catch (Throwable JavaDoc jjte001) {
1322                        if (jjtc001) {
1323                            jjtree.clearNodeScope(jjtn001);
1324                            jjtc001 = false;
1325                        } else {
1326                            jjtree.popNode();
1327                        }
1328                        if (jjte001 instanceof RuntimeException JavaDoc) {
1329                            {
1330                                if (true)
1331                                    throw (RuntimeException JavaDoc) jjte001;
1332                            }
1333                        }
1334                        if (jjte001 instanceof ParseException) {
1335                            {
1336                                if (true)
1337                                    throw (ParseException) jjte001;
1338                            }
1339                        }
1340                        {
1341                            if (true)
1342                                throw (Error JavaDoc) jjte001;
1343                        }
1344                    } finally {
1345                        if (jjtc001) {
1346                            jjtree.closeNodeScope(jjtn001, 2);
1347                        }
1348                    }
1349                    break;
1350                case 38:
1351                    jj_consume_token(38);
1352                    ASTDivNode jjtn002 = new ASTDivNode(this, JJTDIVNODE);
1353                    boolean jjtc002 = true;
1354                    jjtree.openNodeScope(jjtn002);
1355                    try {
1356                        UnaryExpression();
1357                    } catch (Throwable JavaDoc jjte002) {
1358                        if (jjtc002) {
1359                            jjtree.clearNodeScope(jjtn002);
1360                            jjtc002 = false;
1361                        } else {
1362                            jjtree.popNode();
1363                        }
1364                        if (jjte002 instanceof RuntimeException JavaDoc) {
1365                            {
1366                                if (true)
1367                                    throw (RuntimeException JavaDoc) jjte002;
1368                            }
1369                        }
1370                        if (jjte002 instanceof ParseException) {
1371                            {
1372                                if (true)
1373                                    throw (ParseException) jjte002;
1374                            }
1375                        }
1376                        {
1377                            if (true)
1378                                throw (Error JavaDoc) jjte002;
1379                        }
1380                    } finally {
1381                        if (jjtc002) {
1382                            jjtree.closeNodeScope(jjtn002, 2);
1383                        }
1384                    }
1385                    break;
1386                case 39:
1387                    jj_consume_token(39);
1388                    ASTDivNode jjtn003 = new ASTDivNode(this, JJTDIVNODE);
1389                    boolean jjtc003 = true;
1390                    jjtree.openNodeScope(jjtn003);
1391                    try {
1392                        UnaryExpression();
1393                    } catch (Throwable JavaDoc jjte003) {
1394                        if (jjtc003) {
1395                            jjtree.clearNodeScope(jjtn003);
1396                            jjtc003 = false;
1397                        } else {
1398                            jjtree.popNode();
1399                        }
1400                        if (jjte003 instanceof RuntimeException JavaDoc) {
1401                            {
1402                                if (true)
1403                                    throw (RuntimeException JavaDoc) jjte003;
1404                            }
1405                        }
1406                        if (jjte003 instanceof ParseException) {
1407                            {
1408                                if (true)
1409                                    throw (ParseException) jjte003;
1410                            }
1411                        }
1412                        {
1413                            if (true)
1414                                throw (Error JavaDoc) jjte003;
1415                        }
1416                    } finally {
1417                        if (jjtc003) {
1418                            jjtree.closeNodeScope(jjtn003, 2);
1419                        }
1420                    }
1421                    break;
1422                case 40:
1423                    jj_consume_token(40);
1424                    ASTModNode jjtn004 = new ASTModNode(this, JJTMODNODE);
1425                    boolean jjtc004 = true;
1426                    jjtree.openNodeScope(jjtn004);
1427                    try {
1428                        UnaryExpression();
1429                    } catch (Throwable JavaDoc jjte004) {
1430                        if (jjtc004) {
1431                            jjtree.clearNodeScope(jjtn004);
1432                            jjtc004 = false;
1433                        } else {
1434                            jjtree.popNode();
1435                        }
1436                        if (jjte004 instanceof RuntimeException JavaDoc) {
1437                            {
1438                                if (true)
1439                                    throw (RuntimeException JavaDoc) jjte004;
1440                            }
1441                        }
1442                        if (jjte004 instanceof ParseException) {
1443                            {
1444                                if (true)
1445                                    throw (ParseException) jjte004;
1446                            }
1447                        }
1448                        {
1449                            if (true)
1450                                throw (Error JavaDoc) jjte004;
1451                        }
1452                    } finally {
1453                        if (jjtc004) {
1454                            jjtree.closeNodeScope(jjtn004, 2);
1455                        }
1456                    }
1457                    break;
1458                case 41:
1459                    jj_consume_token(41);
1460                    ASTModNode jjtn005 = new ASTModNode(this, JJTMODNODE);
1461                    boolean jjtc005 = true;
1462                    jjtree.openNodeScope(jjtn005);
1463                    try {
1464                        UnaryExpression();
1465                    } catch (Throwable JavaDoc jjte005) {
1466                        if (jjtc005) {
1467                            jjtree.clearNodeScope(jjtn005);
1468                            jjtc005 = false;
1469                        } else {
1470                            jjtree.popNode();
1471                        }
1472                        if (jjte005 instanceof RuntimeException JavaDoc) {
1473                            {
1474                                if (true)
1475                                    throw (RuntimeException JavaDoc) jjte005;
1476                            }
1477                        }
1478                        if (jjte005 instanceof ParseException) {
1479                            {
1480                                if (true)
1481                                    throw (ParseException) jjte005;
1482                            }
1483                        }
1484                        {
1485                            if (true)
1486                                throw (Error JavaDoc) jjte005;
1487                        }
1488                    } finally {
1489                        if (jjtc005) {
1490                            jjtree.closeNodeScope(jjtn005, 2);
1491                        }
1492                    }
1493                    break;
1494                default:
1495                    jj_la1[18] = jj_gen;
1496                    jj_consume_token(-1);
1497                    throw new ParseException();
1498            }
1499        }
1500    }
1501
1502    final public void UnaryExpression() throws ParseException {
1503        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1504            case 36:
1505                jj_consume_token(36);
1506                ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(this, JJTUNARYMINUSNODE);
1507                boolean jjtc001 = true;
1508                jjtree.openNodeScope(jjtn001);
1509                try {
1510                    UnaryExpression();
1511                } catch (Throwable JavaDoc jjte001) {
1512                    if (jjtc001) {
1513                        jjtree.clearNodeScope(jjtn001);
1514                        jjtc001 = false;
1515                    } else {
1516                        jjtree.popNode();
1517                    }
1518                    if (jjte001 instanceof RuntimeException JavaDoc) {
1519                        {
1520                            if (true)
1521                                throw (RuntimeException JavaDoc) jjte001;
1522                        }
1523                    }
1524                    if (jjte001 instanceof ParseException) {
1525                        {
1526                            if (true)
1527                                throw (ParseException) jjte001;
1528                        }
1529                    }
1530                    {
1531                        if (true)
1532                            throw (Error JavaDoc) jjte001;
1533                    }
1534                } finally {
1535                    if (jjtc001) {
1536                        jjtree.closeNodeScope(jjtn001, 1);
1537                    }
1538                }
1539                break;
1540            case 42:
1541                jj_consume_token(42);
1542                ASTBitwiseComplNode jjtn002 = new ASTBitwiseComplNode(this, JJTBITWISECOMPLNODE);
1543                boolean jjtc002 = true;
1544                jjtree.openNodeScope(jjtn002);
1545                try {
1546                    UnaryExpression();
1547                } catch (Throwable JavaDoc jjte002) {
1548                    if (jjtc002) {
1549                        jjtree.clearNodeScope(jjtn002);
1550                        jjtc002 = false;
1551                    } else {
1552                        jjtree.popNode();
1553                    }
1554                    if (jjte002 instanceof RuntimeException JavaDoc) {
1555                        {
1556                            if (true)
1557                                throw (RuntimeException JavaDoc) jjte002;
1558                        }
1559                    }
1560                    if (jjte002 instanceof ParseException) {
1561                        {
1562                            if (true)
1563                                throw (ParseException) jjte002;
1564                        }
1565                    }
1566                    {
1567                        if (true)
1568                            throw (Error JavaDoc) jjte002;
1569                    }
1570                } finally {
1571                    if (jjtc002) {
1572                        jjtree.closeNodeScope(jjtn002, 1);
1573                    }
1574                }
1575                break;
1576            case 43:
1577                jj_consume_token(43);
1578                ASTNotNode jjtn003 = new ASTNotNode(this, JJTNOTNODE);
1579                boolean jjtc003 = true;
1580                jjtree.openNodeScope(jjtn003);
1581                try {
1582                    UnaryExpression();
1583                } catch (Throwable JavaDoc jjte003) {
1584                    if (jjtc003) {
1585                        jjtree.clearNodeScope(jjtn003);
1586                        jjtc003 = false;
1587                    } else {
1588                        jjtree.popNode();
1589                    }
1590                    if (jjte003 instanceof RuntimeException JavaDoc) {
1591                        {
1592                            if (true)
1593                                throw (RuntimeException JavaDoc) jjte003;
1594                        }
1595                    }
1596                    if (jjte003 instanceof ParseException) {
1597                        {
1598                            if (true)
1599                                throw (ParseException) jjte003;
1600                        }
1601                    }
1602                    {
1603                        if (true)
1604                            throw (Error JavaDoc) jjte003;
1605                    }
1606                } finally {
1607                    if (jjtc003) {
1608                        jjtree.closeNodeScope(jjtn003, 1);
1609                    }
1610                }
1611                break;
1612            case 44:
1613                jj_consume_token(44);
1614                ASTNotNode jjtn004 = new ASTNotNode(this, JJTNOTNODE);
1615                boolean jjtc004 = true;
1616                jjtree.openNodeScope(jjtn004);
1617                try {
1618                    UnaryExpression();
1619                } catch (Throwable JavaDoc jjte004) {
1620                    if (jjtc004) {
1621                        jjtree.clearNodeScope(jjtn004);
1622                        jjtc004 = false;
1623                    } else {
1624                        jjtree.popNode();
1625                    }
1626                    if (jjte004 instanceof RuntimeException JavaDoc) {
1627                        {
1628                            if (true)
1629                                throw (RuntimeException JavaDoc) jjte004;
1630                        }
1631                    }
1632                    if (jjte004 instanceof ParseException) {
1633                        {
1634                            if (true)
1635                                throw (ParseException) jjte004;
1636                        }
1637                    }
1638                    {
1639                        if (true)
1640                            throw (Error JavaDoc) jjte004;
1641                    }
1642                } finally {
1643                    if (jjtc004) {
1644                        jjtree.closeNodeScope(jjtn004, 1);
1645                    }
1646                }
1647                break;
1648            case INTEGER_LITERAL:
1649            case FLOAT_LITERAL:
1650            case 11:
1651            case 12:
1652            case 14:
1653            case 45:
1654            case 46:
1655            case 47:
1656            case IDENTIFIER:
1657            case STRING_LITERAL:
1658                PrimaryExpression();
1659                break;
1660            default:
1661                jj_la1[19] = jj_gen;
1662                jj_consume_token(-1);
1663                throw new ParseException();
1664        }
1665    }
1666
1667    final public void PrimaryExpression() throws ParseException {
1668        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1669            case INTEGER_LITERAL:
1670            case FLOAT_LITERAL:
1671            case 45:
1672            case 46:
1673            case 47:
1674            case STRING_LITERAL:
1675                Literal();
1676                break;
1677            case IDENTIFIER:
1678                Reference();
1679                break;
1680            case 12:
1681                jj_consume_token(12);
1682                Expression();
1683                jj_consume_token(13);
1684                break;
1685            case 11:
1686                EmptyFunction();
1687                break;
1688            case 14:
1689                SizeFunction();
1690                break;
1691            default:
1692                jj_la1[20] = jj_gen;
1693                jj_consume_token(-1);
1694                throw new ParseException();
1695        }
1696    }
1697
1698    final public void Literal() throws ParseException {
1699        Token t;
1700        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1701            case INTEGER_LITERAL:
1702                IntegerLiteral();
1703                break;
1704            case FLOAT_LITERAL:
1705                FloatLiteral();
1706                break;
1707            case 46:
1708            case 47:
1709                BooleanLiteral();
1710                break;
1711            case STRING_LITERAL:
1712                StringLiteral();
1713                break;
1714            case 45:
1715                NullLiteral();
1716                break;
1717            default:
1718                jj_la1[21] = jj_gen;
1719                jj_consume_token(-1);
1720                throw new ParseException();
1721        }
1722    }
1723
1724    final public void NullLiteral() throws ParseException {
1725        /* @bgen(jjtree) NullLiteral */
1726        ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
1727        boolean jjtc000 = true;
1728        jjtree.openNodeScope(jjtn000);
1729        try {
1730            jj_consume_token(45);
1731        } finally {
1732            if (jjtc000) {
1733                jjtree.closeNodeScope(jjtn000, true);
1734            }
1735        }
1736    }
1737
1738    final public void BooleanLiteral() throws ParseException {
1739        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1740            case 46:
1741                ASTTrueNode jjtn001 = new ASTTrueNode(this, JJTTRUENODE);
1742                boolean jjtc001 = true;
1743                jjtree.openNodeScope(jjtn001);
1744                try {
1745                    jj_consume_token(46);
1746                } finally {
1747                    if (jjtc001) {
1748                        jjtree.closeNodeScope(jjtn001, true);
1749                    }
1750                }
1751                break;
1752            case 47:
1753                ASTFalseNode jjtn002 = new ASTFalseNode(this, JJTFALSENODE);
1754                boolean jjtc002 = true;
1755                jjtree.openNodeScope(jjtn002);
1756                try {
1757                    jj_consume_token(47);
1758                } finally {
1759                    if (jjtc002) {
1760                        jjtree.closeNodeScope(jjtn002, true);
1761                    }
1762                }
1763                break;
1764            default:
1765                jj_la1[22] = jj_gen;
1766                jj_consume_token(-1);
1767                throw new ParseException();
1768        }
1769    }
1770
1771    final public void IntegerLiteral() throws ParseException {
1772        /* @bgen(jjtree) IntegerLiteral */
1773        ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(this, JJTINTEGERLITERAL);
1774        boolean jjtc000 = true;
1775        jjtree.openNodeScope(jjtn000);
1776        Token t;
1777        try {
1778            t = jj_consume_token(INTEGER_LITERAL);
1779            jjtree.closeNodeScope(jjtn000, true);
1780            jjtc000 = false;
1781            jjtn000.val = Integer.valueOf(t.image);
1782        } finally {
1783            if (jjtc000) {
1784                jjtree.closeNodeScope(jjtn000, true);
1785            }
1786        }
1787    }
1788
1789    final public void FloatLiteral() throws ParseException {
1790        /* @bgen(jjtree) FloatLiteral */
1791        ASTFloatLiteral jjtn000 = new ASTFloatLiteral(this, JJTFLOATLITERAL);
1792        boolean jjtc000 = true;
1793        jjtree.openNodeScope(jjtn000);
1794        Token t;
1795        try {
1796            t = jj_consume_token(FLOAT_LITERAL);
1797            jjtree.closeNodeScope(jjtn000, true);
1798            jjtc000 = false;
1799            jjtn000.val = Float.valueOf(t.image);
1800        } finally {
1801            if (jjtc000) {
1802                jjtree.closeNodeScope(jjtn000, true);
1803            }
1804        }
1805    }
1806
1807    final public void StringLiteral() throws ParseException {
1808        /* @bgen(jjtree) StringLiteral */
1809        ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
1810        boolean jjtc000 = true;
1811        jjtree.openNodeScope(jjtn000);
1812        Token t;
1813        try {
1814            t = jj_consume_token(STRING_LITERAL);
1815            jjtree.closeNodeScope(jjtn000, true);
1816            jjtc000 = false;
1817            jjtn000.literal = t.image.substring(1, t.image.length() - 1);
1818        } finally {
1819            if (jjtc000) {
1820                jjtree.closeNodeScope(jjtn000, true);
1821            }
1822        }
1823    }
1824
1825    /*
1826     * Statement syntax follows.
1827     */

1828    final public void Statement() throws ParseException {
1829        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1830            case 48:
1831                jj_consume_token(48);
1832                break;
1833            case 9:
1834                Block();
1835                break;
1836            default:
1837                jj_la1[23] = jj_gen;
1838                if (jj_2_2(2147483647)) {
1839                    ReferenceExpression();
1840                } else if (jj_2_3(2147483647)) {
1841                    StatementExpression();
1842                } else {
1843                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1844                        case INTEGER_LITERAL:
1845                        case FLOAT_LITERAL:
1846                        case 11:
1847                        case 12:
1848                        case 14:
1849                        case 36:
1850                        case 42:
1851                        case 43:
1852                        case 44:
1853                        case 45:
1854                        case 46:
1855                        case 47:
1856                        case IDENTIFIER:
1857                        case STRING_LITERAL:
1858                            ExpressionExpression();
1859                            break;
1860                        case 49:
1861                            IfStatement();
1862                            break;
1863                        case 52:
1864                            ForeachStatement();
1865                            break;
1866                        case 51:
1867                            WhileStatement();
1868                            break;
1869                        default:
1870                            jj_la1[24] = jj_gen;
1871                            jj_consume_token(-1);
1872                            throw new ParseException();
1873                    }
1874                }
1875        }
1876    }
1877
1878    final public void ExpressionExpression() throws ParseException {
1879        /* @bgen(jjtree) ExpressionExpression */
1880        ASTExpressionExpression jjtn000 = new ASTExpressionExpression(this, JJTEXPRESSIONEXPRESSION);
1881        boolean jjtc000 = true;
1882        jjtree.openNodeScope(jjtn000);
1883        try {
1884            Expression();
1885            jj_consume_token(48);
1886        } catch (Throwable JavaDoc jjte000) {
1887            if (jjtc000) {
1888                jjtree.clearNodeScope(jjtn000);
1889                jjtc000 = false;
1890            } else {
1891                jjtree.popNode();
1892            }
1893            if (jjte000 instanceof RuntimeException JavaDoc) {
1894                {
1895                    if (true)
1896                        throw (RuntimeException JavaDoc) jjte000;
1897                }
1898            }
1899            if (jjte000 instanceof ParseException) {
1900                {
1901                    if (true)
1902                        throw (ParseException) jjte000;
1903                }
1904            }
1905            {
1906                if (true)
1907                    throw (Error JavaDoc) jjte000;
1908            }
1909        } finally {
1910            if (jjtc000) {
1911                jjtree.closeNodeScope(jjtn000, true);
1912            }
1913        }
1914    }
1915
1916    final public void StatementExpression() throws ParseException {
1917        /* @bgen(jjtree) StatementExpression */
1918        ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
1919        boolean jjtc000 = true;
1920        jjtree.openNodeScope(jjtn000);
1921        try {
1922            Assignment();
1923            jj_consume_token(48);
1924        } catch (Throwable JavaDoc jjte000) {
1925            if (jjtc000) {
1926                jjtree.clearNodeScope(jjtn000);
1927                jjtc000 = false;
1928            } else {
1929                jjtree.popNode();
1930            }
1931            if (jjte000 instanceof RuntimeException JavaDoc) {
1932                {
1933                    if (true)
1934                        throw (RuntimeException JavaDoc) jjte000;
1935                }
1936            }
1937            if (jjte000 instanceof ParseException) {
1938                {
1939                    if (true)
1940                        throw (ParseException) jjte000;
1941                }
1942            }
1943            {
1944                if (true)
1945                    throw (Error JavaDoc) jjte000;
1946            }
1947        } finally {
1948            if (jjtc000) {
1949                jjtree.closeNodeScope(jjtn000, true);
1950            }
1951        }
1952    }
1953
1954    final public void ReferenceExpression() throws ParseException {
1955        /* @bgen(jjtree) ReferenceExpression */
1956        ASTReferenceExpression jjtn000 = new ASTReferenceExpression(this, JJTREFERENCEEXPRESSION);
1957        boolean jjtc000 = true;
1958        jjtree.openNodeScope(jjtn000);
1959        try {
1960            Reference();
1961            jj_consume_token(48);
1962        } catch (Throwable JavaDoc jjte000) {
1963            if (jjtc000) {
1964                jjtree.clearNodeScope(jjtn000);
1965                jjtc000 = false;
1966            } else {
1967                jjtree.popNode();
1968            }
1969            if (jjte000 instanceof RuntimeException JavaDoc) {
1970                {
1971                    if (true)
1972                        throw (RuntimeException JavaDoc) jjte000;
1973                }
1974            }
1975            if (jjte000 instanceof ParseException) {
1976                {
1977                    if (true)
1978                        throw (ParseException) jjte000;
1979                }
1980            }
1981            {
1982                if (true)
1983                    throw (Error JavaDoc) jjte000;
1984            }
1985        } finally {
1986            if (jjtc000) {
1987                jjtree.closeNodeScope(jjtn000, true);
1988            }
1989        }
1990    }
1991
1992    final public void IfStatement() throws ParseException {
1993        /* @bgen(jjtree) IfStatement */
1994        ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
1995        boolean jjtc000 = true;
1996        jjtree.openNodeScope(jjtn000);
1997        try {
1998            jj_consume_token(49);
1999            jj_consume_token(12);
2000            Expression();
2001            jj_consume_token(13);
2002            Statement();
2003            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2004                case 50:
2005                    jj_consume_token(50);
2006                    Statement();
2007                    break;
2008                default:
2009                    jj_la1[25] = jj_gen;
2010                    ;
2011            }
2012        } catch (Throwable JavaDoc jjte000) {
2013            if (jjtc000) {
2014                jjtree.clearNodeScope(jjtn000);
2015                jjtc000 = false;
2016            } else {
2017                jjtree.popNode();
2018            }
2019            if (jjte000 instanceof RuntimeException JavaDoc) {
2020                {
2021                    if (true)
2022                        throw (RuntimeException JavaDoc) jjte000;
2023                }
2024            }
2025            if (jjte000 instanceof ParseException) {
2026                {
2027                    if (true)
2028                        throw (ParseException) jjte000;
2029                }
2030            }
2031            {
2032                if (true)
2033                    throw (Error JavaDoc) jjte000;
2034            }
2035        } finally {
2036            if (jjtc000) {
2037                jjtree.closeNodeScope(jjtn000, true);
2038            }
2039        }
2040    }
2041
2042    final public void WhileStatement() throws ParseException {
2043        /* @bgen(jjtree) WhileStatement */
2044        ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
2045        boolean jjtc000 = true;
2046        jjtree.openNodeScope(jjtn000);
2047        try {
2048            jj_consume_token(51);
2049            jj_consume_token(12);
2050            Expression();
2051            jj_consume_token(13);
2052            Statement();
2053        } catch (Throwable JavaDoc jjte000) {
2054            if (jjtc000) {
2055                jjtree.clearNodeScope(jjtn000);
2056                jjtc000 = false;
2057            } else {
2058                jjtree.popNode();
2059            }
2060            if (jjte000 instanceof RuntimeException JavaDoc) {
2061                {
2062                    if (true)
2063                        throw (RuntimeException JavaDoc) jjte000;
2064                }
2065            }
2066            if (jjte000 instanceof ParseException) {
2067                {
2068                    if (true)
2069                        throw (ParseException) jjte000;
2070                }
2071            }
2072            {
2073                if (true)
2074                    throw (Error JavaDoc) jjte000;
2075            }
2076        } finally {
2077            if (jjtc000) {
2078                jjtree.closeNodeScope(jjtn000, true);
2079            }
2080        }
2081    }
2082
2083    final public void ForeachStatement() throws ParseException {
2084        /* @bgen(jjtree) ForeachStatement */
2085        ASTForeachStatement jjtn000 = new ASTForeachStatement(this, JJTFOREACHSTATEMENT);
2086        boolean jjtc000 = true;
2087        jjtree.openNodeScope(jjtn000);
2088        try {
2089            jj_consume_token(52);
2090            jj_consume_token(12);
2091            Reference();
2092            jj_consume_token(53);
2093            Reference();
2094            jj_consume_token(13);
2095            Statement();
2096        } catch (Throwable JavaDoc jjte000) {
2097            if (jjtc000) {
2098                jjtree.clearNodeScope(jjtn000);
2099                jjtc000 = false;
2100            } else {
2101                jjtree.popNode();
2102            }
2103            if (jjte000 instanceof RuntimeException JavaDoc) {
2104                {
2105                    if (true)
2106                        throw (RuntimeException JavaDoc) jjte000;
2107                }
2108            }
2109            if (jjte000 instanceof ParseException) {
2110                {
2111                    if (true)
2112                        throw (ParseException) jjte000;
2113                }
2114            }
2115            {
2116                if (true)
2117                    throw (Error JavaDoc) jjte000;
2118            }
2119        } finally {
2120            if (jjtc000) {
2121                jjtree.closeNodeScope(jjtn000, true);
2122            }
2123        }
2124    }
2125
2126    final public void Method() throws ParseException {
2127        /* @bgen(jjtree) Method */
2128        ASTMethod jjtn000 = new ASTMethod(this, JJTMETHOD);
2129        boolean jjtc000 = true;
2130        jjtree.openNodeScope(jjtn000);
2131        try {
2132            Identifier();
2133            jj_consume_token(12);
2134            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2135                case INTEGER_LITERAL:
2136                case FLOAT_LITERAL:
2137                case 11:
2138                case 12:
2139                case 14:
2140                case 36:
2141                case 42:
2142                case 43:
2143                case 44:
2144                case 45:
2145                case 46:
2146                case 47:
2147                case IDENTIFIER:
2148                case STRING_LITERAL:
2149                    Parameter();
2150                    label_12: while (true) {
2151                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2152                            case 54:
2153                                ;
2154                                break;
2155                            default:
2156                                jj_la1[26] = jj_gen;
2157                                break label_12;
2158                        }
2159                        jj_consume_token(54);
2160                        Parameter();
2161                    }
2162                    break;
2163                default:
2164                    jj_la1[27] = jj_gen;
2165                    ;
2166            }
2167            jj_consume_token(13);
2168        } catch (Throwable JavaDoc jjte000) {
2169            if (jjtc000) {
2170                jjtree.clearNodeScope(jjtn000);
2171                jjtc000 = false;
2172            } else {
2173                jjtree.popNode();
2174            }
2175            if (jjte000 instanceof RuntimeException JavaDoc) {
2176                {
2177                    if (true)
2178                        throw (RuntimeException JavaDoc) jjte000;
2179                }
2180            }
2181            if (jjte000 instanceof ParseException) {
2182                {
2183                    if (true)
2184                        throw (ParseException) jjte000;
2185                }
2186            }
2187            {
2188                if (true)
2189                    throw (Error JavaDoc) jjte000;
2190            }
2191        } finally {
2192            if (jjtc000) {
2193                jjtree.closeNodeScope(jjtn000, true);
2194            }
2195        }
2196    }
2197
2198    final public void ArrayAccess() throws ParseException {
2199        /* @bgen(jjtree) ArrayAccess */
2200        ASTArrayAccess jjtn000 = new ASTArrayAccess(this, JJTARRAYACCESS);
2201        boolean jjtc000 = true;
2202        jjtree.openNodeScope(jjtn000);
2203        try {
2204            Identifier();
2205            label_13: while (true) {
2206                jj_consume_token(55);
2207                if (jj_2_4(3)) {
2208                    Expression();
2209                } else {
2210                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2211                        case INTEGER_LITERAL:
2212                            IntegerLiteral();
2213                            break;
2214                        case IDENTIFIER:
2215                            Reference();
2216                            break;
2217                        default:
2218                            jj_la1[28] = jj_gen;
2219                            jj_consume_token(-1);
2220                            throw new ParseException();
2221                    }
2222                }
2223                jj_consume_token(56);
2224                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2225                    case 55:
2226                        ;
2227                        break;
2228                    default:
2229                        jj_la1[29] = jj_gen;
2230                        break label_13;
2231                }
2232            }
2233        } catch (Throwable JavaDoc jjte000) {
2234            if (jjtc000) {
2235                jjtree.clearNodeScope(jjtn000);
2236                jjtc000 = false;
2237            } else {
2238                jjtree.popNode();
2239            }
2240            if (jjte000 instanceof RuntimeException JavaDoc) {
2241                {
2242                    if (true)
2243                        throw (RuntimeException JavaDoc) jjte000;
2244                }
2245            }
2246            if (jjte000 instanceof ParseException) {
2247                {
2248                    if (true)
2249                        throw (ParseException) jjte000;
2250                }
2251            }
2252            {
2253                if (true)
2254                    throw (Error JavaDoc) jjte000;
2255            }
2256        } finally {
2257            if (jjtc000) {
2258                jjtree.closeNodeScope(jjtn000, true);
2259            }
2260        }
2261    }
2262
2263    final public void SizeMethod() throws ParseException {
2264        /* @bgen(jjtree) SizeMethod */
2265        ASTSizeMethod jjtn000 = new ASTSizeMethod(this, JJTSIZEMETHOD);
2266        boolean jjtc000 = true;
2267        jjtree.openNodeScope(jjtn000);
2268        try {
2269            jj_consume_token(14);
2270            jj_consume_token(12);
2271            jj_consume_token(13);
2272        } finally {
2273            if (jjtc000) {
2274                jjtree.closeNodeScope(jjtn000, true);
2275            }
2276        }
2277    }
2278
2279    final public void Reference() throws ParseException {
2280        /* @bgen(jjtree) Reference */
2281        ASTReference jjtn000 = new ASTReference(this, JJTREFERENCE);
2282        boolean jjtc000 = true;
2283        jjtree.openNodeScope(jjtn000);
2284        try {
2285            if (jj_2_5(2147483647)) {
2286                ArrayAccess();
2287            } else {
2288                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2289                    case IDENTIFIER:
2290                        Identifier();
2291                        break;
2292                    default:
2293                        jj_la1[30] = jj_gen;
2294                        jj_consume_token(-1);
2295                        throw new ParseException();
2296                }
2297            }
2298            label_14: while (true) {
2299                if (jj_2_6(2)) {
2300                    ;
2301                } else {
2302                    break label_14;
2303                }
2304                jj_consume_token(57);
2305                if (jj_2_8(2147483647)) {
2306                    ArrayAccess();
2307                } else {
2308                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2309                        case INTEGER_LITERAL:
2310                        case 14:
2311                        case IDENTIFIER:
2312                            if (jj_2_7(3)) {
2313                                Method();
2314                            } else {
2315                                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2316                                    case 14:
2317                                        SizeMethod();
2318                                        break;
2319                                    case IDENTIFIER:
2320                                        Identifier();
2321                                        break;
2322                                    case INTEGER_LITERAL:
2323                                        IntegerLiteral();
2324                                        break;
2325                                    default:
2326                                        jj_la1[31] = jj_gen;
2327                                        jj_consume_token(-1);
2328                                        throw new ParseException();
2329                                }
2330                            }
2331                            break;
2332                        default:
2333                            jj_la1[32] = jj_gen;
2334                            jj_consume_token(-1);
2335                            throw new ParseException();
2336                    }
2337                }
2338            }
2339        } catch (Throwable JavaDoc jjte000) {
2340            if (jjtc000) {
2341                jjtree.clearNodeScope(jjtn000);
2342                jjtc000 = false;
2343            } else {
2344                jjtree.popNode();
2345            }
2346            if (jjte000 instanceof RuntimeException JavaDoc) {
2347                {
2348                    if (true)
2349                        throw (RuntimeException JavaDoc) jjte000;
2350                }
2351            }
2352            if (jjte000 instanceof ParseException) {
2353                {
2354                    if (true)
2355                        throw (ParseException) jjte000;
2356                }
2357            }
2358            {
2359                if (true)
2360                    throw (Error JavaDoc) jjte000;
2361            }
2362        } finally {
2363            if (jjtc000) {
2364                jjtree.closeNodeScope(jjtn000, true);
2365            }
2366        }
2367    }
2368
2369    final public void Parameter() throws ParseException {
2370        if (jj_2_9(3)) {
2371            Expression();
2372        } else {
2373            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2374                case INTEGER_LITERAL:
2375                case FLOAT_LITERAL:
2376                case 45:
2377                case 46:
2378                case 47:
2379                case STRING_LITERAL:
2380                    Literal();
2381                    break;
2382                case IDENTIFIER:
2383                    Reference();
2384                    break;
2385                default:
2386                    jj_la1[33] = jj_gen;
2387                    jj_consume_token(-1);
2388                    throw new ParseException();
2389            }
2390        }
2391    }
2392
2393    final private boolean jj_2_1(int xla) {
2394        jj_la = xla;
2395        jj_lastpos = jj_scanpos = token;
2396        boolean retval = !jj_3_1();
2397        jj_save(0, xla);
2398        return retval;
2399    }
2400
2401    final private boolean jj_2_2(int xla) {
2402        jj_la = xla;
2403        jj_lastpos = jj_scanpos = token;
2404        boolean retval = !jj_3_2();
2405        jj_save(1, xla);
2406        return retval;
2407    }
2408
2409    final private boolean jj_2_3(int xla) {
2410        jj_la = xla;
2411        jj_lastpos = jj_scanpos = token;
2412        boolean retval = !jj_3_3();
2413        jj_save(2, xla);
2414        return retval;
2415    }
2416
2417    final private boolean jj_2_4(int xla) {
2418        jj_la = xla;
2419        jj_lastpos = jj_scanpos = token;
2420        boolean retval = !jj_3_4();
2421        jj_save(3, xla);
2422        return retval;
2423    }
2424
2425    final private boolean jj_2_5(int xla) {
2426        jj_la = xla;
2427        jj_lastpos = jj_scanpos = token;
2428        boolean retval = !jj_3_5();
2429        jj_save(4, xla);
2430        return retval;
2431    }
2432
2433    final private boolean jj_2_6(int xla) {
2434        jj_la = xla;
2435        jj_lastpos = jj_scanpos = token;
2436        boolean retval = !jj_3_6();
2437        jj_save(5, xla);
2438        return retval;
2439    }
2440
2441    final private boolean jj_2_7(int xla) {
2442        jj_la = xla;
2443        jj_lastpos = jj_scanpos = token;
2444        boolean retval = !jj_3_7();
2445        jj_save(6, xla);
2446        return retval;
2447    }
2448
2449    final private boolean jj_2_8(int xla) {
2450        jj_la = xla;
2451        jj_lastpos = jj_scanpos = token;
2452        boolean retval = !jj_3_8();
2453        jj_save(7, xla);
2454        return retval;
2455    }
2456
2457    final private boolean jj_2_9(int xla) {
2458        jj_la = xla;
2459        jj_lastpos = jj_scanpos = token;
2460        boolean retval = !jj_3_9();
2461        jj_save(8, xla);
2462        return retval;
2463    }
2464
2465    final private boolean jj_3R_71() {
2466        if (jj_scan_token(17))
2467            return true;
2468        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2469            return false;
2470        if (jj_3R_58())
2471            return true;
2472        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2473            return false;
2474        return false;
2475    }
2476
2477    final private boolean jj_3R_59() {
2478        Token xsp;
2479        xsp = jj_scanpos;
2480        if (jj_3R_70()) {
2481            jj_scanpos = xsp;
2482            if (jj_3R_71())
2483                return true;
2484            if (jj_la == 0 && jj_scanpos == jj_lastpos)
2485                return false;
2486        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2487            return false;
2488        return false;
2489    }
2490
2491    final private boolean jj_3R_70() {
2492        if (jj_scan_token(16))
2493            return true;
2494        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2495            return false;
2496        if (jj_3R_58())
2497            return true;
2498        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2499            return false;
2500        return false;
2501    }
2502
2503    final private boolean jj_3R_64() {
2504        if (jj_scan_token(STRING_LITERAL))
2505            return true;
2506        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2507            return false;
2508        return false;
2509    }
2510
2511    final private boolean jj_3R_47() {
2512        if (jj_3R_58())
2513            return true;
2514        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2515            return false;
2516        Token xsp;
2517        while (true) {
2518            xsp = jj_scanpos;
2519            if (jj_3R_59()) {
2520                jj_scanpos = xsp;
2521                break;
2522            }
2523            if (jj_la == 0 && jj_scanpos == jj_lastpos)
2524                return false;
2525        }
2526        return false;
2527    }
2528
2529    final private boolean jj_3_1() {
2530        if (jj_3R_15())
2531            return true;
2532        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2533            return false;
2534        if (jj_scan_token(15))
2535            return true;
2536        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2537            return false;
2538        return false;
2539    }
2540
2541    final private boolean jj_3R_46() {
2542        if (jj_3R_15())
2543            return true;
2544        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2545            return false;
2546        if (jj_scan_token(15))
2547            return true;
2548        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2549            return false;
2550        if (jj_3R_17())
2551            return true;
2552        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2553            return false;
2554        return false;
2555    }
2556
2557    final private boolean jj_3R_34() {
2558        if (jj_3R_18())
2559            return true;
2560        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2561            return false;
2562        return false;
2563    }
2564
2565    final private boolean jj_3R_62() {
2566        if (jj_scan_token(FLOAT_LITERAL))
2567            return true;
2568        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2569            return false;
2570        return false;
2571    }
2572
2573    final private boolean jj_3R_36() {
2574        if (jj_3R_47())
2575            return true;
2576        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2577            return false;
2578        return false;
2579    }
2580
2581    final private boolean jj_3R_35() {
2582        if (jj_3R_46())
2583            return true;
2584        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2585            return false;
2586        return false;
2587    }
2588
2589    final private boolean jj_3R_17() {
2590        Token xsp;
2591        xsp = jj_scanpos;
2592        if (jj_3R_35()) {
2593            jj_scanpos = xsp;
2594            if (jj_3R_36())
2595                return true;
2596            if (jj_la == 0 && jj_scanpos == jj_lastpos)
2597                return false;
2598        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2599            return false;
2600        return false;
2601    }
2602
2603    final private boolean jj_3R_56() {
2604        if (jj_scan_token(12))
2605            return true;
2606        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2607            return false;
2608        if (jj_3R_16())
2609            return true;
2610        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2611            return false;
2612        if (jj_scan_token(13))
2613            return true;
2614        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2615            return false;
2616        return false;
2617    }
2618
2619    final private boolean jj_3R_37() {
2620        if (jj_scan_token(INTEGER_LITERAL))
2621            return true;
2622        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2623            return false;
2624        return false;
2625    }
2626
2627    final private boolean jj_3R_18() {
2628        if (jj_scan_token(IDENTIFIER))
2629            return true;
2630        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2631            return false;
2632        return false;
2633    }
2634
2635    final private boolean jj_3R_73() {
2636        if (jj_scan_token(47))
2637            return true;
2638        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2639            return false;
2640        return false;
2641    }
2642
2643    final private boolean jj_3R_63() {
2644        Token xsp;
2645        xsp = jj_scanpos;
2646        if (jj_3R_72()) {
2647            jj_scanpos = xsp;
2648            if (jj_3R_73())
2649                return true;
2650            if (jj_la == 0 && jj_scanpos == jj_lastpos)
2651                return false;
2652        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2653            return false;
2654        return false;
2655    }
2656
2657    final private boolean jj_3R_72() {
2658        if (jj_scan_token(46))
2659            return true;
2660        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2661            return false;
2662        return false;
2663    }
2664
2665    final private boolean jj_3R_45() {
2666        if (jj_scan_token(14))
2667            return true;
2668        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2669            return false;
2670        if (jj_scan_token(12))
2671            return true;
2672        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2673            return false;
2674        if (jj_3R_16())
2675            return true;
2676        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2677            return false;
2678        if (jj_scan_token(13))
2679            return true;
2680        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2681            return false;
2682        return false;
2683    }
2684
2685    final private boolean jj_3R_27() {
2686        if (jj_3R_16())
2687            return true;
2688        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2689            return false;
2690        return false;
2691    }
2692
2693    final private boolean jj_3R_65() {
2694        if (jj_scan_token(45))
2695            return true;
2696        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2697            return false;
2698        return false;
2699    }
2700
2701    final private boolean jj_3R_55() {
2702        if (jj_3R_16())
2703            return true;
2704        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2705            return false;
2706        return false;
2707    }
2708
2709    final private boolean jj_3R_41() {
2710        if (jj_3R_37())
2711            return true;
2712        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2713            return false;
2714        return false;
2715    }
2716
2717    final private boolean jj_3R_44() {
2718        if (jj_scan_token(11))
2719            return true;
2720        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2721            return false;
2722        Token xsp;
2723        xsp = jj_scanpos;
2724        if (jj_3R_55()) {
2725            jj_scanpos = xsp;
2726            if (jj_3R_56())
2727                return true;
2728            if (jj_la == 0 && jj_scanpos == jj_lastpos)
2729                return false;
2730        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2731            return false;
2732        return false;
2733    }
2734
2735    final private boolean jj_3R_21() {
2736        if (jj_3R_16())
2737            return true;
2738        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2739            return false;
2740        return false;
2741    }
2742
2743    final private boolean jj_3R_54() {
2744        if (jj_3R_65())
2745            return true;
2746        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2747            return false;
2748        return false;
2749    }
2750
2751    final private boolean jj_3R_53() {
2752        if (jj_3R_64())
2753            return true;
2754        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2755            return false;
2756        return false;
2757    }
2758
2759    final private boolean jj_3R_67() {
2760        if (jj_3R_16())
2761            return true;
2762        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2763            return false;
2764        return false;
2765    }
2766
2767    final private boolean jj_3R_52() {
2768        if (jj_3R_63())
2769            return true;
2770        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2771            return false;
2772        return false;
2773    }
2774
2775    final private boolean jj_3R_61() {
2776        if (jj_3R_16())
2777            return true;
2778        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2779            return false;
2780        return false;
2781    }
2782
2783    final private boolean jj_3R_51() {
2784        if (jj_3R_62())
2785            return true;
2786        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2787            return false;
2788        return false;
2789    }
2790
2791    final private boolean jj_3R_43() {
2792        Token xsp;
2793        xsp = jj_scanpos;
2794        if (jj_3R_50()) {
2795            jj_scanpos = xsp;
2796            if (jj_3R_51()) {
2797                jj_scanpos = xsp;
2798                if (jj_3R_52()) {
2799                    jj_scanpos = xsp;
2800                    if (jj_3R_53()) {
2801                        jj_scanpos = xsp;
2802                        if (jj_3R_54())
2803                            return true;
2804                        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2805                            return false;
2806                    } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2807                        return false;
2808                } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2809                    return false;
2810            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2811                return false;
2812        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2813            return false;
2814        return false;
2815    }
2816
2817    final private boolean jj_3R_50() {
2818        if (jj_3R_37())
2819            return true;
2820        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2821            return false;
2822        return false;
2823    }
2824
2825    final private boolean jj_3R_26() {
2826        if (jj_3R_37())
2827            return true;
2828        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2829            return false;
2830        return false;
2831    }
2832
2833    final private boolean jj_3R_40() {
2834        if (jj_3R_18())
2835            return true;
2836        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2837            return false;
2838        return false;
2839    }
2840
2841    final private boolean jj_3R_20() {
2842        if (jj_3R_37())
2843            return true;
2844        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2845            return false;
2846        return false;
2847    }
2848
2849    final private boolean jj_3R_32() {
2850        if (jj_3R_45())
2851            return true;
2852        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2853            return false;
2854        return false;
2855    }
2856
2857    final private boolean jj_3R_60() {
2858        if (jj_3R_43())
2859            return true;
2860        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2861            return false;
2862        return false;
2863    }
2864
2865    final private boolean jj_3R_31() {
2866        if (jj_3R_44())
2867            return true;
2868        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2869            return false;
2870        return false;
2871    }
2872
2873    final private boolean jj_3R_30() {
2874        if (jj_scan_token(12))
2875            return true;
2876        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2877            return false;
2878        if (jj_3R_17())
2879            return true;
2880        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2881            return false;
2882        if (jj_scan_token(13))
2883            return true;
2884        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2885            return false;
2886        return false;
2887    }
2888
2889    final private boolean jj_3R_66() {
2890        if (jj_3R_37())
2891            return true;
2892        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2893            return false;
2894        return false;
2895    }
2896
2897    final private boolean jj_3R_29() {
2898        if (jj_3R_16())
2899            return true;
2900        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2901            return false;
2902        return false;
2903    }
2904
2905    final private boolean jj_3R_28() {
2906        if (jj_3R_43())
2907            return true;
2908        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2909            return false;
2910        return false;
2911    }
2912
2913    final private boolean jj_3R_15() {
2914        Token xsp;
2915        xsp = jj_scanpos;
2916        if (jj_3R_28()) {
2917            jj_scanpos = xsp;
2918            if (jj_3R_29()) {
2919                jj_scanpos = xsp;
2920                if (jj_3R_30()) {
2921                    jj_scanpos = xsp;
2922                    if (jj_3R_31()) {
2923                        jj_scanpos = xsp;
2924                        if (jj_3R_32())
2925                            return true;
2926                        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2927                            return false;
2928                    } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2929                        return false;
2930                } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2931                    return false;
2932            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2933                return false;
2934        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2935            return false;
2936        return false;
2937    }
2938
2939    final private boolean jj_3R_25() {
2940        if (jj_3R_17())
2941            return true;
2942        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2943            return false;
2944        return false;
2945    }
2946
2947    final private boolean jj_3R_39() {
2948        if (jj_3R_48())
2949            return true;
2950        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2951            return false;
2952        return false;
2953    }
2954
2955    final private boolean jj_3R_109() {
2956        if (jj_3R_15())
2957            return true;
2958        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2959            return false;
2960        return false;
2961    }
2962
2963    final private boolean jj_3R_19() {
2964        if (jj_3R_17())
2965            return true;
2966        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2967            return false;
2968        return false;
2969    }
2970
2971    final private boolean jj_3R_108() {
2972        if (jj_scan_token(44))
2973            return true;
2974        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2975            return false;
2976        if (jj_3R_101())
2977            return true;
2978        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2979            return false;
2980        return false;
2981    }
2982
2983    final private boolean jj_3R_107() {
2984        if (jj_scan_token(43))
2985            return true;
2986        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2987            return false;
2988        if (jj_3R_101())
2989            return true;
2990        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2991            return false;
2992        return false;
2993    }
2994
2995    final private boolean jj_3R_106() {
2996        if (jj_scan_token(42))
2997            return true;
2998        if (jj_la == 0 && jj_scanpos == jj_lastpos)
2999            return false;
3000        if (jj_3R_101())
3001            return true;
3002        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3003            return false;
3004        return false;
3005    }
3006
3007    final private boolean jj_3R_105() {
3008        if (jj_scan_token(36))
3009            return true;
3010        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3011            return false;
3012        if (jj_3R_101())
3013            return true;
3014        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3015            return false;
3016        return false;
3017    }
3018
3019    final private boolean jj_3R_101() {
3020        Token xsp;
3021        xsp = jj_scanpos;
3022        if (jj_3R_105()) {
3023            jj_scanpos = xsp;
3024            if (jj_3R_106()) {
3025                jj_scanpos = xsp;
3026                if (jj_3R_107()) {
3027                    jj_scanpos = xsp;
3028                    if (jj_3R_108()) {
3029                        jj_scanpos = xsp;
3030                        if (jj_3R_109())
3031                            return true;
3032                        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3033                            return false;
3034                    } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3035                        return false;
3036                } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3037                    return false;
3038            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3039                return false;
3040        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3041            return false;
3042        return false;
3043    }
3044
3045    final private boolean jj_3R_78() {
3046        if (jj_scan_token(54))
3047            return true;
3048        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3049            return false;
3050        if (jj_3R_49())
3051            return true;
3052        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3053            return false;
3054        return false;
3055    }
3056
3057    final private boolean jj_3R_114() {
3058        if (jj_scan_token(41))
3059            return true;
3060        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3061            return false;
3062        if (jj_3R_101())
3063            return true;
3064        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3065            return false;
3066        return false;
3067    }
3068
3069    final private boolean jj_3_8() {
3070        if (jj_3R_18())
3071            return true;
3072        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3073            return false;
3074        if (jj_scan_token(55))
3075            return true;
3076        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3077            return false;
3078        Token xsp;
3079        xsp = jj_scanpos;
3080        if (jj_3R_25()) {
3081            jj_scanpos = xsp;
3082            if (jj_3R_26()) {
3083                jj_scanpos = xsp;
3084                if (jj_3R_27())
3085                    return true;
3086                if (jj_la == 0 && jj_scanpos == jj_lastpos)
3087                    return false;
3088            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3089                return false;
3090        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3091            return false;
3092        if (jj_scan_token(56))
3093            return true;
3094        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3095            return false;
3096        return false;
3097    }
3098
3099    final private boolean jj_3R_113() {
3100        if (jj_scan_token(40))
3101            return true;
3102        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3103            return false;
3104        if (jj_3R_101())
3105            return true;
3106        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3107            return false;
3108        return false;
3109    }
3110
3111    final private boolean jj_3_9() {
3112        if (jj_3R_17())
3113            return true;
3114        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3115            return false;
3116        return false;
3117    }
3118
3119    final private boolean jj_3R_49() {
3120        Token xsp;
3121        xsp = jj_scanpos;
3122        if (jj_3_9()) {
3123            jj_scanpos = xsp;
3124            if (jj_3R_60()) {
3125                jj_scanpos = xsp;
3126                if (jj_3R_61())
3127                    return true;
3128                if (jj_la == 0 && jj_scanpos == jj_lastpos)
3129                    return false;
3130            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3131                return false;
3132        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3133            return false;
3134        return false;
3135    }
3136
3137    final private boolean jj_3R_112() {
3138        if (jj_scan_token(39))
3139            return true;
3140        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3141            return false;
3142        if (jj_3R_101())
3143            return true;
3144        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3145            return false;
3146        return false;
3147    }
3148
3149    final private boolean jj_3_4() {
3150        if (jj_3R_17())
3151            return true;
3152        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3153            return false;
3154        return false;
3155    }
3156
3157    final private boolean jj_3R_111() {
3158        if (jj_scan_token(38))
3159            return true;
3160        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3161            return false;
3162        if (jj_3R_101())
3163            return true;
3164        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3165            return false;
3166        return false;
3167    }
3168
3169    final private boolean jj_3_5() {
3170        if (jj_3R_18())
3171            return true;
3172        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3173            return false;
3174        if (jj_scan_token(55))
3175            return true;
3176        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3177            return false;
3178        Token xsp;
3179        xsp = jj_scanpos;
3180        if (jj_3R_19()) {
3181            jj_scanpos = xsp;
3182            if (jj_3R_20()) {
3183                jj_scanpos = xsp;
3184                if (jj_3R_21())
3185                    return true;
3186                if (jj_la == 0 && jj_scanpos == jj_lastpos)
3187                    return false;
3188            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3189                return false;
3190        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3191            return false;
3192        if (jj_scan_token(56))
3193            return true;
3194        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3195            return false;
3196        return false;
3197    }
3198
3199    final private boolean jj_3_7() {
3200        if (jj_3R_24())
3201            return true;
3202        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3203            return false;
3204        return false;
3205    }
3206
3207    final private boolean jj_3R_110() {
3208        if (jj_scan_token(37))
3209            return true;
3210        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3211            return false;
3212        if (jj_3R_101())
3213            return true;
3214        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3215            return false;
3216        return false;
3217    }
3218
3219    final private boolean jj_3R_102() {
3220        Token xsp;
3221        xsp = jj_scanpos;
3222        if (jj_3R_110()) {
3223            jj_scanpos = xsp;
3224            if (jj_3R_111()) {
3225                jj_scanpos = xsp;
3226                if (jj_3R_112()) {
3227                    jj_scanpos = xsp;
3228                    if (jj_3R_113()) {
3229                        jj_scanpos = xsp;
3230                        if (jj_3R_114())
3231                            return true;
3232                        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3233                            return false;
3234                    } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3235                        return false;
3236                } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3237                    return false;
3238            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3239                return false;
3240        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3241            return false;
3242        return false;
3243    }
3244
3245    final private boolean jj_3R_23() {
3246        Token xsp;
3247        xsp = jj_scanpos;
3248        if (jj_3_7()) {
3249            jj_scanpos = xsp;
3250            if (jj_3R_39()) {
3251                jj_scanpos = xsp;
3252                if (jj_3R_40()) {
3253                    jj_scanpos = xsp;
3254                    if (jj_3R_41())
3255                        return true;
3256                    if (jj_la == 0 && jj_scanpos == jj_lastpos)
3257                        return false;
3258                } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3259                    return false;
3260            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3261                return false;
3262        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3263            return false;
3264        return false;
3265    }
3266
3267    final private boolean jj_3R_22() {
3268        if (jj_3R_38())
3269            return true;
3270        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3271            return false;
3272        return false;
3273    }
3274
3275    final private boolean jj_3R_57() {
3276        if (jj_scan_token(55))
3277            return true;
3278        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3279            return false;
3280        Token xsp;
3281        xsp = jj_scanpos;
3282        if (jj_3_4()) {
3283            jj_scanpos = xsp;
3284            if (jj_3R_66()) {
3285                jj_scanpos = xsp;
3286                if (jj_3R_67())
3287                    return true;
3288                if (jj_la == 0 && jj_scanpos == jj_lastpos)
3289                    return false;
3290            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3291                return false;
3292        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3293            return false;
3294        if (jj_scan_token(56))
3295            return true;
3296        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3297            return false;
3298        return false;
3299    }
3300
3301    final private boolean jj_3R_91() {
3302        if (jj_3R_101())
3303            return true;
3304        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3305            return false;
3306        Token xsp;
3307        while (true) {
3308            xsp = jj_scanpos;
3309            if (jj_3R_102()) {
3310                jj_scanpos = xsp;
3311                break;
3312            }
3313            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3314                return false;
3315        }
3316        return false;
3317    }
3318
3319    final private boolean jj_3R_42() {
3320        if (jj_3R_49())
3321            return true;
3322        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3323            return false;
3324        Token xsp;
3325        while (true) {
3326            xsp = jj_scanpos;
3327            if (jj_3R_78()) {
3328                jj_scanpos = xsp;
3329                break;
3330            }
3331            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3332                return false;
3333        }
3334        return false;
3335    }
3336
3337    final private boolean jj_3_6() {
3338        if (jj_scan_token(57))
3339            return true;
3340        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3341            return false;
3342        Token xsp;
3343        xsp = jj_scanpos;
3344        if (jj_3R_22()) {
3345            jj_scanpos = xsp;
3346            if (jj_3R_23())
3347                return true;
3348            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3349                return false;
3350        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3351            return false;
3352        return false;
3353    }
3354
3355    final private boolean jj_3R_33() {
3356        if (jj_3R_38())
3357            return true;
3358        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3359            return false;
3360        return false;
3361    }
3362
3363    final private boolean jj_3R_48() {
3364        if (jj_scan_token(14))
3365            return true;
3366        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3367            return false;
3368        if (jj_scan_token(12))
3369            return true;
3370        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3371            return false;
3372        if (jj_scan_token(13))
3373            return true;
3374        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3375            return false;
3376        return false;
3377    }
3378
3379    final private boolean jj_3R_104() {
3380        if (jj_scan_token(36))
3381            return true;
3382        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3383            return false;
3384        if (jj_3R_91())
3385            return true;
3386        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3387            return false;
3388        return false;
3389    }
3390
3391    final private boolean jj_3R_16() {
3392        Token xsp;
3393        xsp = jj_scanpos;
3394        if (jj_3R_33()) {
3395            jj_scanpos = xsp;
3396            if (jj_3R_34())
3397                return true;
3398            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3399                return false;
3400        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3401            return false;
3402        while (true) {
3403            xsp = jj_scanpos;
3404            if (jj_3_6()) {
3405                jj_scanpos = xsp;
3406                break;
3407            }
3408            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3409                return false;
3410        }
3411        return false;
3412    }
3413
3414    final private boolean jj_3R_103() {
3415        if (jj_scan_token(35))
3416            return true;
3417        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3418            return false;
3419        if (jj_3R_91())
3420            return true;
3421        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3422            return false;
3423        return false;
3424    }
3425
3426    final private boolean jj_3R_92() {
3427        Token xsp;
3428        xsp = jj_scanpos;
3429        if (jj_3R_103()) {
3430            jj_scanpos = xsp;
3431            if (jj_3R_104())
3432                return true;
3433            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3434                return false;
3435        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3436            return false;
3437        return false;
3438    }
3439
3440    final private boolean jj_3R_85() {
3441        if (jj_3R_91())
3442            return true;
3443        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3444            return false;
3445        Token xsp;
3446        while (true) {
3447            xsp = jj_scanpos;
3448            if (jj_3R_92()) {
3449                jj_scanpos = xsp;
3450                break;
3451            }
3452            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3453                return false;
3454        }
3455        return false;
3456    }
3457
3458    final private boolean jj_3R_38() {
3459        if (jj_3R_18())
3460            return true;
3461        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3462            return false;
3463        Token xsp;
3464        if (jj_3R_57())
3465            return true;
3466        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3467            return false;
3468        while (true) {
3469            xsp = jj_scanpos;
3470            if (jj_3R_57()) {
3471                jj_scanpos = xsp;
3472                break;
3473            }
3474            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3475                return false;
3476        }
3477        return false;
3478    }
3479
3480    final private boolean jj_3R_100() {
3481        if (jj_scan_token(34))
3482            return true;
3483        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3484            return false;
3485        if (jj_3R_85())
3486            return true;
3487        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3488            return false;
3489        return false;
3490    }
3491
3492    final private boolean jj_3R_99() {
3493        if (jj_scan_token(33))
3494            return true;
3495        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3496            return false;
3497        if (jj_3R_85())
3498            return true;
3499        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3500            return false;
3501        return false;
3502    }
3503
3504    final private boolean jj_3R_24() {
3505        if (jj_3R_18())
3506            return true;
3507        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3508            return false;
3509        if (jj_scan_token(12))
3510            return true;
3511        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3512            return false;
3513        Token xsp;
3514        xsp = jj_scanpos;
3515        if (jj_3R_42())
3516            jj_scanpos = xsp;
3517        else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3518            return false;
3519        if (jj_scan_token(13))
3520            return true;
3521        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3522            return false;
3523        return false;
3524    }
3525
3526    final private boolean jj_3R_98() {
3527        if (jj_scan_token(32))
3528            return true;
3529        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3530            return false;
3531        if (jj_3R_85())
3532            return true;
3533        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3534            return false;
3535        return false;
3536    }
3537
3538    final private boolean jj_3R_97() {
3539        if (jj_scan_token(31))
3540            return true;
3541        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3542            return false;
3543        if (jj_3R_85())
3544            return true;
3545        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3546            return false;
3547        return false;
3548    }
3549
3550    final private boolean jj_3R_96() {
3551        if (jj_scan_token(30))
3552            return true;
3553        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3554            return false;
3555        if (jj_3R_85())
3556            return true;
3557        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3558            return false;
3559        return false;
3560    }
3561
3562    final private boolean jj_3R_95() {
3563        if (jj_scan_token(29))
3564            return true;
3565        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3566            return false;
3567        if (jj_3R_85())
3568            return true;
3569        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3570            return false;
3571        return false;
3572    }
3573
3574    final private boolean jj_3R_94() {
3575        if (jj_scan_token(28))
3576            return true;
3577        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3578            return false;
3579        if (jj_3R_85())
3580            return true;
3581        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3582            return false;
3583        return false;
3584    }
3585
3586    final private boolean jj_3R_93() {
3587        if (jj_scan_token(27))
3588            return true;
3589        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3590            return false;
3591        if (jj_3R_85())
3592            return true;
3593        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3594            return false;
3595        return false;
3596    }
3597
3598    final private boolean jj_3R_86() {
3599        Token xsp;
3600        xsp = jj_scanpos;
3601        if (jj_3R_93()) {
3602            jj_scanpos = xsp;
3603            if (jj_3R_94()) {
3604                jj_scanpos = xsp;
3605                if (jj_3R_95()) {
3606                    jj_scanpos = xsp;
3607                    if (jj_3R_96()) {
3608                        jj_scanpos = xsp;
3609                        if (jj_3R_97()) {
3610                            jj_scanpos = xsp;
3611                            if (jj_3R_98()) {
3612                                jj_scanpos = xsp;
3613                                if (jj_3R_99()) {
3614                                    jj_scanpos = xsp;
3615                                    if (jj_3R_100())
3616                                        return true;
3617                                    if (jj_la == 0 && jj_scanpos == jj_lastpos)
3618                                        return false;
3619                                } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3620                                    return false;
3621                            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3622                                return false;
3623                        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3624                            return false;
3625                    } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3626                        return false;
3627                } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3628                    return false;
3629            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3630                return false;
3631        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3632            return false;
3633        return false;
3634    }
3635
3636    final private boolean jj_3R_83() {
3637        if (jj_3R_85())
3638            return true;
3639        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3640            return false;
3641        Token xsp;
3642        while (true) {
3643            xsp = jj_scanpos;
3644            if (jj_3R_86()) {
3645                jj_scanpos = xsp;
3646                break;
3647            }
3648            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3649                return false;
3650        }
3651        return false;
3652    }
3653
3654    final private boolean jj_3R_90() {
3655        if (jj_scan_token(26))
3656            return true;
3657        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3658            return false;
3659        if (jj_3R_83())
3660            return true;
3661        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3662            return false;
3663        return false;
3664    }
3665
3666    final private boolean jj_3R_89() {
3667        if (jj_scan_token(25))
3668            return true;
3669        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3670            return false;
3671        if (jj_3R_83())
3672            return true;
3673        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3674            return false;
3675        return false;
3676    }
3677
3678    final private boolean jj_3R_88() {
3679        if (jj_scan_token(24))
3680            return true;
3681        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3682            return false;
3683        if (jj_3R_83())
3684            return true;
3685        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3686            return false;
3687        return false;
3688    }
3689
3690    final private boolean jj_3R_87() {
3691        if (jj_scan_token(23))
3692            return true;
3693        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3694            return false;
3695        if (jj_3R_83())
3696            return true;
3697        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3698            return false;
3699        return false;
3700    }
3701
3702    final private boolean jj_3R_84() {
3703        Token xsp;
3704        xsp = jj_scanpos;
3705        if (jj_3R_87()) {
3706            jj_scanpos = xsp;
3707            if (jj_3R_88()) {
3708                jj_scanpos = xsp;
3709                if (jj_3R_89()) {
3710                    jj_scanpos = xsp;
3711                    if (jj_3R_90())
3712                        return true;
3713                    if (jj_la == 0 && jj_scanpos == jj_lastpos)
3714                        return false;
3715                } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3716                    return false;
3717            } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3718                return false;
3719        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3720            return false;
3721        return false;
3722    }
3723
3724    final private boolean jj_3R_81() {
3725        if (jj_3R_83())
3726            return true;
3727        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3728            return false;
3729        Token xsp;
3730        while (true) {
3731            xsp = jj_scanpos;
3732            if (jj_3R_84()) {
3733                jj_scanpos = xsp;
3734                break;
3735            }
3736            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3737                return false;
3738        }
3739        return false;
3740    }
3741
3742    final private boolean jj_3R_82() {
3743        if (jj_scan_token(22))
3744            return true;
3745        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3746            return false;
3747        if (jj_3R_81())
3748            return true;
3749        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3750            return false;
3751        return false;
3752    }
3753
3754    final private boolean jj_3R_79() {
3755        if (jj_3R_81())
3756            return true;
3757        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3758            return false;
3759        Token xsp;
3760        while (true) {
3761            xsp = jj_scanpos;
3762            if (jj_3R_82()) {
3763                jj_scanpos = xsp;
3764                break;
3765            }
3766            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3767                return false;
3768        }
3769        return false;
3770    }
3771
3772    final private boolean jj_3_3() {
3773        if (jj_3R_15())
3774            return true;
3775        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3776            return false;
3777        if (jj_scan_token(15))
3778            return true;
3779        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3780            return false;
3781        return false;
3782    }
3783
3784    final private boolean jj_3_2() {
3785        if (jj_3R_16())
3786            return true;
3787        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3788            return false;
3789        if (jj_scan_token(48))
3790            return true;
3791        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3792            return false;
3793        return false;
3794    }
3795
3796    final private boolean jj_3R_80() {
3797        if (jj_scan_token(21))
3798            return true;
3799        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3800            return false;
3801        if (jj_3R_79())
3802            return true;
3803        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3804            return false;
3805        return false;
3806    }
3807
3808    final private boolean jj_3R_74() {
3809        if (jj_3R_79())
3810            return true;
3811        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3812            return false;
3813        Token xsp;
3814        while (true) {
3815            xsp = jj_scanpos;
3816            if (jj_3R_80()) {
3817                jj_scanpos = xsp;
3818                break;
3819            }
3820            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3821                return false;
3822        }
3823        return false;
3824    }
3825
3826    final private boolean jj_3R_75() {
3827        if (jj_scan_token(20))
3828            return true;
3829        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3830            return false;
3831        if (jj_3R_74())
3832            return true;
3833        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3834            return false;
3835        return false;
3836    }
3837
3838    final private boolean jj_3R_68() {
3839        if (jj_3R_74())
3840            return true;
3841        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3842            return false;
3843        Token xsp;
3844        while (true) {
3845            xsp = jj_scanpos;
3846            if (jj_3R_75()) {
3847                jj_scanpos = xsp;
3848                break;
3849            }
3850            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3851                return false;
3852        }
3853        return false;
3854    }
3855
3856    final private boolean jj_3R_77() {
3857        if (jj_scan_token(19))
3858            return true;
3859        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3860            return false;
3861        if (jj_3R_68())
3862            return true;
3863        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3864            return false;
3865        return false;
3866    }
3867
3868    final private boolean jj_3R_69() {
3869        Token xsp;
3870        xsp = jj_scanpos;
3871        if (jj_3R_76()) {
3872            jj_scanpos = xsp;
3873            if (jj_3R_77())
3874                return true;
3875            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3876                return false;
3877        } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3878            return false;
3879        return false;
3880    }
3881
3882    final private boolean jj_3R_76() {
3883        if (jj_scan_token(18))
3884            return true;
3885        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3886            return false;
3887        if (jj_3R_68())
3888            return true;
3889        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3890            return false;
3891        return false;
3892    }
3893
3894    final private boolean jj_3R_58() {
3895        if (jj_3R_68())
3896            return true;
3897        if (jj_la == 0 && jj_scanpos == jj_lastpos)
3898            return false;
3899        Token xsp;
3900        while (true) {
3901            xsp = jj_scanpos;
3902            if (jj_3R_69()) {
3903                jj_scanpos = xsp;
3904                break;
3905            }
3906            if (jj_la == 0 && jj_scanpos == jj_lastpos)
3907                return false;
3908        }
3909        return false;
3910    }
3911
3912    public ParserTokenManager token_source;
3913
3914    SimpleCharStream jj_input_stream;
3915
3916    public Token token, jj_nt;
3917
3918    private int jj_ntk;
3919
3920    private Token jj_scanpos, jj_lastpos;
3921
3922    private int jj_la;
3923
3924    public boolean lookingAhead = false;
3925
3926    private boolean jj_semLA;
3927
3928    private int jj_gen;
3929
3930    final private int[] jj_la1 = new int[34];
3931
3932    final private int[] jj_la1_0 = { 0x5b80, 0x5b80, 0x1000, 0x5980, 0x30000, 0x30000, 0xc0000, 0xc0000, 0x100000,
3933        0x200000, 0x400000, 0x7800000, 0x7800000, 0xf8000000, 0xf8000000, 0x0, 0x0, 0x0, 0x0, 0x5980, 0x5980, 0x180,
3934        0x0, 0x200, 0x5980, 0x0, 0x0, 0x5980, 0x80, 0x0, 0x0, 0x4080, 0x4080, 0x180, };
3935
3936    final private int[] jj_la1_1 = { 0x241bfc10, 0x241bfc10, 0x4000000, 0x2400fc10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3937        0x0, 0x0, 0x7, 0x7, 0x18, 0x18, 0x3e0, 0x3e0, 0x2400fc10, 0x2400e000, 0x2000e000, 0xc000, 0x10000, 0x241afc10,
3938        0x40000, 0x400000, 0x2400fc10, 0x4000000, 0x800000, 0x4000000, 0x4000000, 0x4000000, 0x2400e000, };
3939
3940    final private JJCalls[] jj_2_rtns = new JJCalls[9];
3941
3942    private boolean jj_rescan = false;
3943
3944    private int jj_gc = 0;
3945
3946    public Parser(java.io.InputStream JavaDoc stream) {
3947        jj_input_stream = new SimpleCharStream(stream, 1, 1);
3948        token_source = new ParserTokenManager(jj_input_stream);
3949        token = new Token();
3950        jj_ntk = -1;
3951        jj_gen = 0;
3952        for (int i = 0; i < 34; i++)
3953            jj_la1[i] = -1;
3954        for (int i = 0; i < jj_2_rtns.length; i++)
3955            jj_2_rtns[i] = new JJCalls();
3956    }
3957
3958    public void ReInit(java.io.InputStream JavaDoc stream) {
3959        jj_input_stream.ReInit(stream, 1, 1);
3960        token_source.ReInit(jj_input_stream);
3961        token = new Token();
3962        jj_ntk = -1;
3963        jjtree.reset();
3964        jj_gen = 0;
3965        for (int i = 0; i < 34; i++)
3966            jj_la1[i] = -1;
3967        for (int i = 0; i < jj_2_rtns.length; i++)
3968            jj_2_rtns[i] = new JJCalls();
3969    }
3970
3971    public Parser(java.io.Reader JavaDoc stream) {
3972        jj_input_stream = new SimpleCharStream(stream, 1, 1);
3973        token_source = new ParserTokenManager(jj_input_stream);
3974        token = new Token();
3975        jj_ntk = -1;
3976        jj_gen = 0;
3977        for (int i = 0; i < 34; i++)
3978            jj_la1[i] = -1;
3979        for (int i = 0; i < jj_2_rtns.length; i++)
3980            jj_2_rtns[i] = new JJCalls();
3981    }
3982
3983    public void ReInit(java.io.Reader JavaDoc stream) {
3984        jj_input_stream.ReInit(stream, 1, 1);
3985        token_source.ReInit(jj_input_stream);
3986        token = new Token();
3987        jj_ntk = -1;
3988        jjtree.reset();
3989        jj_gen = 0;
3990        for (int i = 0; i < 34; i++)
3991            jj_la1[i] = -1;
3992        for (int i = 0; i < jj_2_rtns.length; i++)
3993            jj_2_rtns[i] = new JJCalls();
3994    }
3995
3996    public Parser(ParserTokenManager tm) {
3997        token_source = tm;
3998        token = new Token();
3999        jj_ntk = -1;
4000        jj_gen = 0;
4001        for (int i = 0; i < 34; i++)
4002            jj_la1[i] = -1;
4003        for (int i = 0; i < jj_2_rtns.length; i++)
4004            jj_2_rtns[i] = new JJCalls();
4005    }
4006
4007    public void ReInit(ParserTokenManager tm) {
4008        token_source = tm;
4009        token = new Token();
4010        jj_ntk = -1;
4011        jjtree.reset();
4012        jj_gen = 0;
4013        for (int i = 0; i < 34; i++)
4014            jj_la1[i] = -1;
4015        for (int i = 0; i < jj_2_rtns.length; i++)
4016            jj_2_rtns[i] = new JJCalls();
4017    }
4018
4019    final private Token jj_consume_token(int kind) throws ParseException {
4020        Token oldToken;
4021        if ((oldToken = token).next != null)
4022            token = token.next;
4023        else
4024            token = token.next = token_source.getNextToken();
4025        jj_ntk = -1;
4026        if (token.kind == kind) {
4027            jj_gen++;
4028            if (++jj_gc > 100) {
4029                jj_gc = 0;
4030                for (int i = 0; i < jj_2_rtns.length; i++) {
4031                    JJCalls c = jj_2_rtns[i];
4032                    while (c != null) {
4033                        if (c.gen < jj_gen)
4034                            c.first = null;
4035                        c = c.next;
4036                    }
4037                }
4038            }
4039            return token;
4040        }
4041        token = oldToken;
4042        jj_kind = kind;
4043        throw generateParseException();
4044    }
4045
4046    final private boolean jj_scan_token(int kind) {
4047        if (jj_scanpos == jj_lastpos) {
4048            jj_la--;
4049            if (jj_scanpos.next == null) {
4050                jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
4051            } else {
4052                jj_lastpos = jj_scanpos = jj_scanpos.next;
4053            }
4054        } else {
4055            jj_scanpos = jj_scanpos.next;
4056        }
4057        if (jj_rescan) {
4058            int i = 0;
4059            Token tok = token;
4060            while (tok != null && tok != jj_scanpos) {
4061                i++;
4062                tok = tok.next;
4063            }
4064            if (tok != null)
4065                jj_add_error_token(kind, i);
4066        }
4067        return (jj_scanpos.kind != kind);
4068    }
4069
4070    final public Token getNextToken() {
4071        if (token.next != null)
4072            token = token.next;
4073        else
4074            token = token.next = token_source.getNextToken();
4075        jj_ntk = -1;
4076        jj_gen++;
4077        return token;
4078    }
4079
4080    final public Token getToken(int index) {
4081        Token t = lookingAhead ? jj_scanpos : token;
4082        for (int i = 0; i < index; i++) {
4083            if (t.next != null)
4084                t = t.next;
4085            else
4086                t = t.next = token_source.getNextToken();
4087        }
4088        return t;
4089    }
4090
4091    final private int jj_ntk() {
4092        if ((jj_nt = token.next) == null)
4093            return (jj_ntk = (token.next = token_source.getNextToken()).kind);
4094        else
4095            return (jj_ntk = jj_nt.kind);
4096    }
4097
4098    private java.util.Vector JavaDoc jj_expentries = new java.util.Vector JavaDoc();
4099
4100    private int[] jj_expentry;
4101
4102    private int jj_kind = -1;
4103
4104    private int[] jj_lasttokens = new int[100];
4105
4106    private int jj_endpos;
4107
4108    private void jj_add_error_token(int kind, int pos) {
4109        if (pos >= 100)
4110            return;
4111        if (pos == jj_endpos + 1) {
4112            jj_lasttokens[jj_endpos++] = kind;
4113        } else if (jj_endpos != 0) {
4114            jj_expentry = new int[jj_endpos];
4115            for (int i = 0; i < jj_endpos; i++) {
4116                jj_expentry[i] = jj_lasttokens[i];
4117            }
4118            boolean exists = false;
4119            for (java.util.Enumeration JavaDoc enumeration = jj_expentries.elements(); enumeration.hasMoreElements();) {
4120                int[] oldentry = (int[]) (enumeration.nextElement());
4121                if (oldentry.length == jj_expentry.length) {
4122                    exists = true;
4123                    for (int i = 0; i < jj_expentry.length; i++) {
4124                        if (oldentry[i] != jj_expentry[i]) {
4125                            exists = false;
4126                            break;
4127                        }
4128                    }
4129                    if (exists)
4130                        break;
4131                }
4132            }
4133            if (!exists)
4134                jj_expentries.addElement(jj_expentry);
4135            if (pos != 0)
4136                jj_lasttokens[(jj_endpos = pos) - 1] = kind;
4137        }
4138    }
4139
4140    final public ParseException generateParseException() {
4141        jj_expentries.removeAllElements();
4142        boolean[] la1tokens = new boolean[62];
4143        for (int i = 0; i < 62; i++) {
4144            la1tokens[i] = false;
4145        }
4146        if (jj_kind >= 0) {
4147            la1tokens[jj_kind] = true;
4148            jj_kind = -1;
4149        }
4150        for (int i = 0; i < 34; i++) {
4151            if (jj_la1[i] == jj_gen) {
4152                for (int j = 0; j < 32; j++) {
4153                    if ((jj_la1_0[i] & (1 << j)) != 0) {
4154                        la1tokens[j] = true;
4155                    }
4156                    if ((jj_la1_1[i] & (1 << j)) != 0) {
4157                        la1tokens[32 + j] = true;
4158                    }
4159                }
4160            }
4161        }
4162        for (int i = 0; i < 62; i++) {
4163            if (la1tokens[i]) {
4164                jj_expentry = new int[1];
4165                jj_expentry[0] = i;
4166                jj_expentries.addElement(jj_expentry);
4167            }
4168        }
4169        jj_endpos = 0;
4170        jj_rescan_token();
4171        jj_add_error_token(0, 0);
4172        int[][] exptokseq = new int[jj_expentries.size()][];
4173        for (int i = 0; i < jj_expentries.size(); i++) {
4174            exptokseq[i] = (int[]) jj_expentries.elementAt(i);
4175        }
4176        return new ParseException(token, exptokseq, tokenImage);
4177    }
4178
4179    final public void enable_tracing() {
4180    }
4181
4182    final public void disable_tracing() {
4183    }
4184
4185    final private void jj_rescan_token() {
4186        jj_rescan = true;
4187        for (int i = 0; i < 9; i++) {
4188            JJCalls p = jj_2_rtns[i];
4189            do {
4190                if (p.gen > jj_gen) {
4191                    jj_la = p.arg;
4192                    jj_lastpos = jj_scanpos = p.first;
4193                    switch (i) {
4194                        case 0:
4195                            jj_3_1();
4196                            break;
4197                        case 1:
4198                            jj_3_2();
4199                            break;
4200                        case 2:
4201                            jj_3_3();
4202                            break;
4203                        case 3:
4204                            jj_3_4();
4205                            break;
4206                        case 4:
4207                            jj_3_5();
4208                            break;
4209                        case 5:
4210                            jj_3_6();
4211                            break;
4212                        case 6:
4213                            jj_3_7();
4214                            break;
4215                        case 7:
4216                            jj_3_8();
4217                            break;
4218                        case 8:
4219                            jj_3_9();
4220                            break;
4221                    }
4222                }
4223                p = p.next;
4224            } while (p != null);
4225        }
4226        jj_rescan = false;
4227    }
4228
4229    final private void jj_save(int index, int xla) {
4230        JJCalls p = jj_2_rtns[index];
4231        while (p.gen > jj_gen) {
4232            if (p.next == null) {
4233                p = p.next = new JJCalls();
4234                break;
4235            }
4236            p = p.next;
4237        }
4238        p.gen = jj_gen + xla - jj_la;
4239        p.first = token;
4240        p.arg = xla;
4241    }
4242
4243    static final class JJCalls {
4244        int gen;
4245
4246        Token first;
4247
4248        int arg;
4249
4250        JJCalls next;
4251    }
4252
4253}
4254
Popular Tags