Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.jexl.parser.Parser$JJCalls |
100% |
100% |

1 |  |
     /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
2 |  |
     package org.apache.commons.jexl.parser;
3 |  |
4 |  |
     import java.io.Reader;
5 |  |
6 |  |
     public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/
7 |  |
       protected JJTParserState jjtree = new JJTParserState();public SimpleNode parse(Reader reader)
8 |  |
             throws Exception
9 |  |
         {
10 |  |
             ReInit(reader);
11 |  |
12 |  |
             /*
13 |  |
              *  lets do the 'Unique Init' in here to be
14 |  |
              *  safe - it's a pain to remember
15 |  |
              */
16 |  |
17 |  |
             SimpleNode tree = JexlScript();
18 |  |
             return tree;
19 |  |
         }
20 |  |
21 |  |
     /*
22 |  |
      * Program structuring syntax follows.
23 |  |
      */
24 |  |
       final public SimpleNode JexlScript() throws ParseException {
25 |  |
      /*@bgen(jjtree) JexlScript */
26 |  |
        ASTJexlScript jjtn000 = new ASTJexlScript(this, JJTJEXLSCRIPT);
27 |  |
        boolean jjtc000 = true;
28 |  |
        jjtree.openNodeScope(jjtn000);String name;
29 |  |
         try {
30 |  |
           label_1:
31 |  |
           while (true) {
32 |  |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
33 |  |
             case INTEGER_LITERAL:
34 |  |
             case FLOAT_LITERAL:
35 |  |
             case 9:
36 |  |
             case 11:
37 |  |
             case 12:
38 |  |
             case 14:
39 |  |
             case 36:
40 |  |
             case 42:
41 |  |
             case 43:
42 |  |
             case 44:
43 |  |
             case 45:
44 |  |
             case 46:
45 |  |
             case 47:
46 |  |
             case 48:
47 |  |
             case 49:
48 |  |
             case 51:
49 |  |
             case 52:
50 |  |
             case IDENTIFIER:
51 |  |
             case STRING_LITERAL:
52 |  |
               ;
53 |  |
               break;
54 |  |
             default:
55 |  |
               jj_la1[0] = jj_gen;
56 |  |
               break label_1;
57 |  |
             }
58 |  |
             Statement();
59 |  |
           }
60 |  |
           jj_consume_token(0);
61 |  |
          jjtree.closeNodeScope(jjtn000, true);
62 |  |
          jjtc000 = false;
63 |  |
          {if (true) return jjtn000;}
64 |  |
         } catch (Throwable jjte000) {
65 |  |
           if (jjtc000) {
66 |  |
             jjtree.clearNodeScope(jjtn000);
67 |  |
             jjtc000 = false;
68 |  |
           } else {
69 |  |
             jjtree.popNode();
70 |  |
           }
71 |  |
           if (jjte000 instanceof RuntimeException) {
72 |  |
             {if (true) throw (RuntimeException)jjte000;}
73 |  |
           }
74 |  |
           if (jjte000 instanceof ParseException) {
75 |  |
             {if (true) throw (ParseException)jjte000;}
76 |  |
           }
77 |  |
           {if (true) throw (Error)jjte000;}
78 |  |
         } finally {
79 |  |
           if (jjtc000) {
80 |  |
             jjtree.closeNodeScope(jjtn000, true);
81 |  |
           }
82 |  |
         }
83 |  |
         throw new Error("Missing return statement in function");
84 |  |
       }
85 |  |
86 |  |
       final public void Block() throws ParseException {
87 |  |
      /*@bgen(jjtree) Block */
88 |  |
       ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
89 |  |
       boolean jjtc000 = true;
90 |  |
       jjtree.openNodeScope(jjtn000);
91 |  |
         try {
92 |  |
           jj_consume_token(9);
93 |  |
           label_2:
94 |  |
           while (true) {
95 |  |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
96 |  |
             case INTEGER_LITERAL:
97 |  |
             case FLOAT_LITERAL:
98 |  |
             case 9:
99 |  |
             case 11:
100 |  |
             case 12:
101 |  |
             case 14:
102 |  |
             case 36:
103 |  |
             case 42:
104 |  |
             case 43:
105 |  |
             case 44:
106 |  |
             case 45:
107 |  |
             case 46:
108 |  |
             case 47:
109 |  |
             case 48:
110 |  |
             case 49:
111 |  |
             case 51:
112 |  |
             case 52:
113 |  |
             case IDENTIFIER:
114 |  |
             case STRING_LITERAL:
115 |  |
               ;
116 |  |
               break;
117 |  |
             default:
118 |  |
               jj_la1[1] = jj_gen;
119 |  |
               break label_2;
120 |  |
             }
121 |  |
             Statement();
122 |  |
           }
123 |  |
           jj_consume_token(10);
124 |  |
         } catch (Throwable jjte000) {
125 |  |
         if (jjtc000) {
126 |  |
           jjtree.clearNodeScope(jjtn000);
127 |  |
           jjtc000 = false;
128 |  |
         } else {
129 |  |
           jjtree.popNode();
130 |  |
         }
131 |  |
         if (jjte000 instanceof RuntimeException) {
132 |  |
           {if (true) throw (RuntimeException)jjte000;}
133 |  |
         }
134 |  |
         if (jjte000 instanceof ParseException) {
135 |  |
           {if (true) throw (ParseException)jjte000;}
136 |  |
         }
137 |  |
         {if (true) throw (Error)jjte000;}
138 |  |
         } finally {
139 |  |
         if (jjtc000) {
140 |  |
           jjtree.closeNodeScope(jjtn000, true);
141 |  |
         }
142 |  |
         }
143 |  |
       }
144 |  |
145 |  |
       final public void EmptyFunction() throws ParseException {
146 |  |
                             /*@bgen(jjtree) EmptyFunction */
147 |  |
       ASTEmptyFunction jjtn000 = new ASTEmptyFunction(this, JJTEMPTYFUNCTION);
148 |  |
       boolean jjtc000 = true;
149 |  |
       jjtree.openNodeScope(jjtn000);
150 |  |
         try {
151 |  |
           jj_consume_token(11);
152 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
153 |  |
           case IDENTIFIER:
154 |  |
             Reference();
155 |  |
             break;
156 |  |
           case 12:
157 |  |
             jj_consume_token(12);
158 |  |
             Reference();
159 |  |
             jj_consume_token(13);
160 |  |
             break;
161 |  |
           default:
162 |  |
             jj_la1[2] = jj_gen;
163 |  |
             jj_consume_token(-1);
164 |  |
             throw new ParseException();
165 |  |
           }
166 |  |
         } catch (Throwable jjte000) {
167 |  |
           if (jjtc000) {
168 |  |
             jjtree.clearNodeScope(jjtn000);
169 |  |
             jjtc000 = false;
170 |  |
           } else {
171 |  |
             jjtree.popNode();
172 |  |
           }
173 |  |
           if (jjte000 instanceof RuntimeException) {
174 |  |
             {if (true) throw (RuntimeException)jjte000;}
175 |  |
           }
176 |  |
           if (jjte000 instanceof ParseException) {
177 |  |
             {if (true) throw (ParseException)jjte000;}
178 |  |
           }
179 |  |
           {if (true) throw (Error)jjte000;}
180 |  |
         } finally {
181 |  |
           if (jjtc000) {
182 |  |
             jjtree.closeNodeScope(jjtn000, true);
183 |  |
           }
184 |  |
         }
185 |  |
       }
186 |  |
187 |  |
       final public void SizeFunction() throws ParseException {
188 |  |
                            /*@bgen(jjtree) SizeFunction */
189 |  |
       ASTSizeFunction jjtn000 = new ASTSizeFunction(this, JJTSIZEFUNCTION);
190 |  |
       boolean jjtc000 = true;
191 |  |
       jjtree.openNodeScope(jjtn000);
192 |  |
         try {
193 |  |
           jj_consume_token(14);
194 |  |
           jj_consume_token(12);
195 |  |
           Reference();
196 |  |
           jj_consume_token(13);
197 |  |
         } catch (Throwable jjte000) {
198 |  |
           if (jjtc000) {
199 |  |
             jjtree.clearNodeScope(jjtn000);
200 |  |
             jjtc000 = false;
201 |  |
           } else {
202 |  |
             jjtree.popNode();
203 |  |
           }
204 |  |
           if (jjte000 instanceof RuntimeException) {
205 |  |
             {if (true) throw (RuntimeException)jjte000;}
206 |  |
           }
207 |  |
           if (jjte000 instanceof ParseException) {
208 |  |
             {if (true) throw (ParseException)jjte000;}
209 |  |
           }
210 |  |
           {if (true) throw (Error)jjte000;}
211 |  |
         } finally {
212 |  |
           if (jjtc000) {
213 |  |
             jjtree.closeNodeScope(jjtn000, true);
214 |  |
           }
215 |  |
         }
216 |  |
       }
217 |  |
218 |  |
       final public void Identifier() throws ParseException {
219 |  |
      /*@bgen(jjtree) Identifier */
220 |  |
        ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER);
221 |  |
        boolean jjtc000 = true;
222 |  |
        jjtree.openNodeScope(jjtn000);Token t;
223 |  |
         try {
224 |  |
           t = jj_consume_token(IDENTIFIER);
225 |  |
           jjtree.closeNodeScope(jjtn000, true);
226 |  |
           jjtc000 = false;
227 |  |
            jjtn000.val = t.image;
228 |  |
         } finally {
229 |  |
           if (jjtc000) {
230 |  |
             jjtree.closeNodeScope(jjtn000, true);
231 |  |
           }
232 |  |
         }
233 |  |
       }
234 |  |
235 |  |
     /*
236 |  |
      * Expression syntax follows.
237 |  |
      */
238 |  |
       final public void Expression() throws ParseException {
239 |  |
                          /*@bgen(jjtree) Expression */
240 |  |
       ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
241 |  |
       boolean jjtc000 = true;
242 |  |
       jjtree.openNodeScope(jjtn000);
243 |  |
         try {
244 |  |
           if (jj_2_1(2147483647)) {
245 |  |
             Assignment();
246 |  |
           } else {
247 |  |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
248 |  |
             case INTEGER_LITERAL:
249 |  |
             case FLOAT_LITERAL:
250 |  |
             case 11:
251 |  |
             case 12:
252 |  |
             case 14:
253 |  |
             case 36:
254 |  |
             case 42:
255 |  |
             case 43:
256 |  |
             case 44:
257 |  |
             case 45:
258 |  |
             case 46:
259 |  |
             case 47:
260 |  |
             case IDENTIFIER:
261 |  |
             case STRING_LITERAL:
262 |  |
               ConditionalOrExpression();
263 |  |
               break;
264 |  |
             default:
265 |  |
               jj_la1[3] = jj_gen;
266 |  |
               jj_consume_token(-1);
267 |  |
               throw new ParseException();
268 |  |
             }
269 |  |
           }
270 |  |
         } catch (Throwable jjte000) {
271 |  |
         if (jjtc000) {
272 |  |
           jjtree.clearNodeScope(jjtn000);
273 |  |
           jjtc000 = false;
274 |  |
         } else {
275 |  |
           jjtree.popNode();
276 |  |
         }
277 |  |
         if (jjte000 instanceof RuntimeException) {
278 |  |
           {if (true) throw (RuntimeException)jjte000;}
279 |  |
         }
280 |  |
         if (jjte000 instanceof ParseException) {
281 |  |
           {if (true) throw (ParseException)jjte000;}
282 |  |
         }
283 |  |
         {if (true) throw (Error)jjte000;}
284 |  |
         } finally {
285 |  |
         if (jjtc000) {
286 |  |
           jjtree.closeNodeScope(jjtn000, true);
287 |  |
         }
288 |  |
         }
289 |  |
       }
290 |  |
291 |  |
       final public void Assignment() throws ParseException {
292 |  |
      /*@bgen(jjtree) #Assignment( 2) */
293 |  |
       ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
294 |  |
       boolean jjtc000 = true;
295 |  |
       jjtree.openNodeScope(jjtn000);
296 |  |
         try {
297 |  |
           PrimaryExpression();
298 |  |
           jj_consume_token(15);
299 |  |
           Expression();
300 |  |
         } catch (Throwable jjte000) {
301 |  |
         if (jjtc000) {
302 |  |
           jjtree.clearNodeScope(jjtn000);
303 |  |
           jjtc000 = false;
304 |  |
         } else {
305 |  |
           jjtree.popNode();
306 |  |
         }
307 |  |
         if (jjte000 instanceof RuntimeException) {
308 |  |
           {if (true) throw (RuntimeException)jjte000;}
309 |  |
         }
310 |  |
         if (jjte000 instanceof ParseException) {
311 |  |
           {if (true) throw (ParseException)jjte000;}
312 |  |
         }
313 |  |
         {if (true) throw (Error)jjte000;}
314 |  |
         } finally {
315 |  |
         if (jjtc000) {
316 |  |
           jjtree.closeNodeScope(jjtn000,  2);
317 |  |
         }
318 |  |
         }
319 |  |
       }
320 |  |
321 |  |
       final public void ConditionalOrExpression() throws ParseException {
322 |  |
         ConditionalAndExpression();
323 |  |
         label_3:
324 |  |
         while (true) {
325 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
326 |  |
           case 16:
327 |  |
           case 17:
328 |  |
             ;
329 |  |
             break;
330 |  |
           default:
331 |  |
             jj_la1[4] = jj_gen;
332 |  |
             break label_3;
333 |  |
           }
334 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
335 |  |
           case 16:
336 |  |
             jj_consume_token(16);
337 |  |
                ASTOrNode jjtn001 = new ASTOrNode(this, JJTORNODE);
338 |  |
                boolean jjtc001 = true;
339 |  |
                jjtree.openNodeScope(jjtn001);
340 |  |
             try {
341 |  |
               ConditionalAndExpression();
342 |  |
             } catch (Throwable jjte001) {
343 |  |
                if (jjtc001) {
344 |  |
                  jjtree.clearNodeScope(jjtn001);
345 |  |
                  jjtc001 = false;
346 |  |
                } else {
347 |  |
                  jjtree.popNode();
348 |  |
                }
349 |  |
                if (jjte001 instanceof RuntimeException) {
350 |  |
                  {if (true) throw (RuntimeException)jjte001;}
351 |  |
                }
352 |  |
                if (jjte001 instanceof ParseException) {
353 |  |
                  {if (true) throw (ParseException)jjte001;}
354 |  |
                }
355 |  |
                {if (true) throw (Error)jjte001;}
356 |  |
             } finally {
357 |  |
                if (jjtc001) {
358 |  |
                  jjtree.closeNodeScope(jjtn001,  2);
359 |  |
                }
360 |  |
             }
361 |  |
             break;
362 |  |
           case 17:
363 |  |
             jj_consume_token(17);
364 |  |
                ASTOrNode jjtn002 = new ASTOrNode(this, JJTORNODE);
365 |  |
                boolean jjtc002 = true;
366 |  |
                jjtree.openNodeScope(jjtn002);
367 |  |
             try {
368 |  |
               ConditionalAndExpression();
369 |  |
             } catch (Throwable jjte002) {
370 |  |
                if (jjtc002) {
371 |  |
                  jjtree.clearNodeScope(jjtn002);
372 |  |
                  jjtc002 = false;
373 |  |
                } else {
374 |  |
                  jjtree.popNode();
375 |  |
                }
376 |  |
                if (jjte002 instanceof RuntimeException) {
377 |  |
                  {if (true) throw (RuntimeException)jjte002;}
378 |  |
                }
379 |  |
                if (jjte002 instanceof ParseException) {
380 |  |
                  {if (true) throw (ParseException)jjte002;}
381 |  |
                }
382 |  |
                {if (true) throw (Error)jjte002;}
383 |  |
             } finally {
384 |  |
                if (jjtc002) {
385 |  |
                  jjtree.closeNodeScope(jjtn002,  2);
386 |  |
                }
387 |  |
             }
388 |  |
             break;
389 |  |
           default:
390 |  |
             jj_la1[5] = jj_gen;
391 |  |
             jj_consume_token(-1);
392 |  |
             throw new ParseException();
393 |  |
           }
394 |  |
         }
395 |  |
       }
396 |  |
397 |  |
       final public void ConditionalAndExpression() throws ParseException {
398 |  |
         InclusiveOrExpression();
399 |  |
         label_4:
400 |  |
         while (true) {
401 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
402 |  |
           case 18:
403 |  |
           case 19:
404 |  |
             ;
405 |  |
             break;
406 |  |
           default:
407 |  |
             jj_la1[6] = jj_gen;
408 |  |
             break label_4;
409 |  |
           }
410 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
411 |  |
           case 18:
412 |  |
             jj_consume_token(18);
413 |  |
                ASTAndNode jjtn001 = new ASTAndNode(this, JJTANDNODE);
414 |  |
                boolean jjtc001 = true;
415 |  |
                jjtree.openNodeScope(jjtn001);
416 |  |
             try {
417 |  |
               InclusiveOrExpression();
418 |  |
             } catch (Throwable jjte001) {
419 |  |
                if (jjtc001) {
420 |  |
                  jjtree.clearNodeScope(jjtn001);
421 |  |
                  jjtc001 = false;
422 |  |
                } else {
423 |  |
                  jjtree.popNode();
424 |  |
                }
425 |  |
                if (jjte001 instanceof RuntimeException) {
426 |  |
                  {if (true) throw (RuntimeException)jjte001;}
427 |  |
                }
428 |  |
                if (jjte001 instanceof ParseException) {
429 |  |
                  {if (true) throw (ParseException)jjte001;}
430 |  |
                }
431 |  |
                {if (true) throw (Error)jjte001;}
432 |  |
             } finally {
433 |  |
                if (jjtc001) {
434 |  |
                  jjtree.closeNodeScope(jjtn001,  2);
435 |  |
                }
436 |  |
             }
437 |  |
             break;
438 |  |
           case 19:
439 |  |
             jj_consume_token(19);
440 |  |
                 ASTAndNode jjtn002 = new ASTAndNode(this, JJTANDNODE);
441 |  |
                 boolean jjtc002 = true;
442 |  |
                 jjtree.openNodeScope(jjtn002);
443 |  |
             try {
444 |  |
               InclusiveOrExpression();
445 |  |
             } catch (Throwable jjte002) {
446 |  |
                 if (jjtc002) {
447 |  |
                   jjtree.clearNodeScope(jjtn002);
448 |  |
                   jjtc002 = false;
449 |  |
                 } else {
450 |  |
                   jjtree.popNode();
451 |  |
                 }
452 |  |
                 if (jjte002 instanceof RuntimeException) {
453 |  |
                   {if (true) throw (RuntimeException)jjte002;}
454 |  |
                 }
455 |  |
                 if (jjte002 instanceof ParseException) {
456 |  |
                   {if (true) throw (ParseException)jjte002;}
457 |  |
                 }
458 |  |
                 {if (true) throw (Error)jjte002;}
459 |  |
             } finally {
460 |  |
                 if (jjtc002) {
461 |  |
                   jjtree.closeNodeScope(jjtn002,  2);
462 |  |
                 }
463 |  |
             }
464 |  |
             break;
465 |  |
           default:
466 |  |
             jj_la1[7] = jj_gen;
467 |  |
             jj_consume_token(-1);
468 |  |
             throw new ParseException();
469 |  |
           }
470 |  |
         }
471 |  |
       }
472 |  |
473 |  |
       final public void InclusiveOrExpression() throws ParseException {
474 |  |
         ExclusiveOrExpression();
475 |  |
         label_5:
476 |  |
         while (true) {
477 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
478 |  |
           case 20:
479 |  |
             ;
480 |  |
             break;
481 |  |
           default:
482 |  |
             jj_la1[8] = jj_gen;
483 |  |
             break label_5;
484 |  |
           }
485 |  |
           jj_consume_token(20);
486 |  |
               ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(this, JJTBITWISEORNODE);
487 |  |
               boolean jjtc001 = true;
488 |  |
               jjtree.openNodeScope(jjtn001);
489 |  |
           try {
490 |  |
             ExclusiveOrExpression();
491 |  |
           } catch (Throwable jjte001) {
492 |  |
               if (jjtc001) {
493 |  |
                 jjtree.clearNodeScope(jjtn001);
494 |  |
                 jjtc001 = false;
495 |  |
               } else {
496 |  |
                 jjtree.popNode();
497 |  |
               }
498 |  |
               if (jjte001 instanceof RuntimeException) {
499 |  |
                 {if (true) throw (RuntimeException)jjte001;}
500 |  |
               }
501 |  |
               if (jjte001 instanceof ParseException) {
502 |  |
                 {if (true) throw (ParseException)jjte001;}
503 |  |
               }
504 |  |
               {if (true) throw (Error)jjte001;}
505 |  |
           } finally {
506 |  |
               if (jjtc001) {
507 |  |
                 jjtree.closeNodeScope(jjtn001,  2);
508 |  |
               }
509 |  |
           }
510 |  |
         }
511 |  |
       }
512 |  |
513 |  |
       final public void ExclusiveOrExpression() throws ParseException {
514 |  |
         AndExpression();
515 |  |
         label_6:
516 |  |
         while (true) {
517 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
518 |  |
           case 21:
519 |  |
             ;
520 |  |
             break;
521 |  |
           default:
522 |  |
             jj_la1[9] = jj_gen;
523 |  |
             break label_6;
524 |  |
           }
525 |  |
           jj_consume_token(21);
526 |  |
               ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(this, JJTBITWISEXORNODE);
527 |  |
               boolean jjtc001 = true;
528 |  |
               jjtree.openNodeScope(jjtn001);
529 |  |
           try {
530 |  |
             AndExpression();
531 |  |
           } catch (Throwable jjte001) {
532 |  |
               if (jjtc001) {
533 |  |
                 jjtree.clearNodeScope(jjtn001);
534 |  |
                 jjtc001 = false;
535 |  |
               } else {
536 |  |
                 jjtree.popNode();
537 |  |
               }
538 |  |
               if (jjte001 instanceof RuntimeException) {
539 |  |
                 {if (true) throw (RuntimeException)jjte001;}
540 |  |
               }
541 |  |
               if (jjte001 instanceof ParseException) {
542 |  |
                 {if (true) throw (ParseException)jjte001;}
543 |  |
               }
544 |  |
               {if (true) throw (Error)jjte001;}
545 |  |
           } finally {
546 |  |
               if (jjtc001) {
547 |  |
                 jjtree.closeNodeScope(jjtn001,  2);
548 |  |
               }
549 |  |
           }
550 |  |
         }
551 |  |
       }
552 |  |
553 |  |
       final public void AndExpression() throws ParseException {
554 |  |
         EqualityExpression();
555 |  |
         label_7:
556 |  |
         while (true) {
557 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
558 |  |
           case 22:
559 |  |
             ;
560 |  |
             break;
561 |  |
           default:
562 |  |
             jj_la1[10] = jj_gen;
563 |  |
             break label_7;
564 |  |
           }
565 |  |
           jj_consume_token(22);
566 |  |
               ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(this, JJTBITWISEANDNODE);
567 |  |
               boolean jjtc001 = true;
568 |  |
               jjtree.openNodeScope(jjtn001);
569 |  |
           try {
570 |  |
             EqualityExpression();
571 |  |
           } catch (Throwable jjte001) {
572 |  |
               if (jjtc001) {
573 |  |
                 jjtree.clearNodeScope(jjtn001);
574 |  |
                 jjtc001 = false;
575 |  |
               } else {
576 |  |
                 jjtree.popNode();
577 |  |
               }
578 |  |
               if (jjte001 instanceof RuntimeException) {
579 |  |
                 {if (true) throw (RuntimeException)jjte001;}
580 |  |
               }
581 |  |
               if (jjte001 instanceof ParseException) {
582 |  |
                 {if (true) throw (ParseException)jjte001;}
583 |  |
               }
584 |  |
               {if (true) throw (Error)jjte001;}
585 |  |
           } finally {
586 |  |
               if (jjtc001) {
587 |  |
                 jjtree.closeNodeScope(jjtn001,  2);
588 |  |
               }
589 |  |
           }
590 |  |
         }
591 |  |
       }
592 |  |
593 |  |
       final public void EqualityExpression() throws ParseException {
594 |  |
         RelationalExpression();
595 |  |
         label_8:
596 |  |
         while (true) {
597 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
598 |  |
           case 23:
599 |  |
           case 24:
600 |  |
           case 25:
601 |  |
           case 26:
602 |  |
             ;
603 |  |
             break;
604 |  |
           default:
605 |  |
             jj_la1[11] = jj_gen;
606 |  |
             break label_8;
607 |  |
           }
608 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
609 |  |
           case 23:
610 |  |
             jj_consume_token(23);
611 |  |
                 ASTEQNode jjtn001 = new ASTEQNode(this, JJTEQNODE);
612 |  |
                 boolean jjtc001 = true;
613 |  |
                 jjtree.openNodeScope(jjtn001);
614 |  |
             try {
615 |  |
               RelationalExpression();
616 |  |
             } catch (Throwable jjte001) {
617 |  |
                 if (jjtc001) {
618 |  |
                   jjtree.clearNodeScope(jjtn001);
619 |  |
                   jjtc001 = false;
620 |  |
                 } else {
621 |  |
                   jjtree.popNode();
622 |  |
                 }
623 |  |
                 if (jjte001 instanceof RuntimeException) {
624 |  |
                   {if (true) throw (RuntimeException)jjte001;}
625 |  |
                 }
626 |  |
                 if (jjte001 instanceof ParseException) {
627 |  |
                   {if (true) throw (ParseException)jjte001;}
628 |  |
                 }
629 |  |
                 {if (true) throw (Error)jjte001;}
630 |  |
             } finally {
631 |  |
                 if (jjtc001) {
632 |  |
                   jjtree.closeNodeScope(jjtn001,  2);
633 |  |
                 }
634 |  |
             }
635 |  |
             break;
636 |  |
           case 24:
637 |  |
             jj_consume_token(24);
638 |  |
                 ASTEQNode jjtn002 = new ASTEQNode(this, JJTEQNODE);
639 |  |
                 boolean jjtc002 = true;
640 |  |
                 jjtree.openNodeScope(jjtn002);
641 |  |
             try {
642 |  |
               RelationalExpression();
643 |  |
             } catch (Throwable jjte002) {
644 |  |
                 if (jjtc002) {
645 |  |
                   jjtree.clearNodeScope(jjtn002);
646 |  |
                   jjtc002 = false;
647 |  |
                 } else {
648 |  |
                   jjtree.popNode();
649 |  |
                 }
650 |  |
                 if (jjte002 instanceof RuntimeException) {
651 |  |
                   {if (true) throw (RuntimeException)jjte002;}
652 |  |
                 }
653 |  |
                 if (jjte002 instanceof ParseException) {
654 |  |
                   {if (true) throw (ParseException)jjte002;}
655 |  |
                 }
656 |  |
                 {if (true) throw (Error)jjte002;}
657 |  |
             } finally {
658 |  |
                 if (jjtc002) {
659 |  |
                   jjtree.closeNodeScope(jjtn002,  2);
660 |  |
                 }
661 |  |
             }
662 |  |
             break;
663 |  |
           case 25:
664 |  |
             jj_consume_token(25);
665 |  |
                 ASTNENode jjtn003 = new ASTNENode(this, JJTNENODE);
666 |  |
                 boolean jjtc003 = true;
667 |  |
                 jjtree.openNodeScope(jjtn003);
668 |  |
             try {
669 |  |
               RelationalExpression();
670 |  |
             } catch (Throwable jjte003) {
671 |  |
                 if (jjtc003) {
672 |  |
                   jjtree.clearNodeScope(jjtn003);
673 |  |
                   jjtc003 = false;
674 |  |
                 } else {
675 |  |
                   jjtree.popNode();
676 |  |
                 }
677 |  |
                 if (jjte003 instanceof RuntimeException) {
678 |  |
                   {if (true) throw (RuntimeException)jjte003;}
679 |  |
                 }
680 |  |
                 if (jjte003 instanceof ParseException) {
681 |  |
                   {if (true) throw (ParseException)jjte003;}
682 |  |
                 }
683 |  |
                 {if (true) throw (Error)jjte003;}
684 |  |
             } finally {
685 |  |
                 if (jjtc003) {
686 |  |
                   jjtree.closeNodeScope(jjtn003,  2);
687 |  |
                 }
688 |  |
             }
689 |  |
             break;
690 |  |
           case 26:
691 |  |
             jj_consume_token(26);
692 |  |
                 ASTNENode jjtn004 = new ASTNENode(this, JJTNENODE);
693 |  |
                 boolean jjtc004 = true;
694 |  |
                 jjtree.openNodeScope(jjtn004);
695 |  |
             try {
696 |  |
               RelationalExpression();
697 |  |
             } catch (Throwable jjte004) {
698 |  |
                 if (jjtc004) {
699 |  |
                   jjtree.clearNodeScope(jjtn004);
700 |  |
                   jjtc004 = false;
701 |  |
                 } else {
702 |  |
                   jjtree.popNode();
703 |  |
                 }
704 |  |
                 if (jjte004 instanceof RuntimeException) {
705 |  |
                   {if (true) throw (RuntimeException)jjte004;}
706 |  |
                 }
707 |  |
                 if (jjte004 instanceof ParseException) {
708 |  |
                   {if (true) throw (ParseException)jjte004;}
709 |  |
                 }
710 |  |
                 {if (true) throw (Error)jjte004;}
711 |  |
             } finally {
712 |  |
                 if (jjtc004) {
713 |  |
                   jjtree.closeNodeScope(jjtn004,  2);
714 |  |
                 }
715 |  |
             }
716 |  |
             break;
717 |  |
           default:
718 |  |
             jj_la1[12] = jj_gen;
719 |  |
             jj_consume_token(-1);
720 |  |
             throw new ParseException();
721 |  |
           }
722 |  |
         }
723 |  |
       }
724 |  |
725 |  |
       final public void RelationalExpression() throws ParseException {
726 |  |
         AdditiveExpression();
727 |  |
         label_9:
728 |  |
         while (true) {
729 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
730 |  |
           case 27:
731 |  |
           case 28:
732 |  |
           case 29:
733 |  |
           case 30:
734 |  |
           case 31:
735 |  |
           case 32:
736 |  |
           case 33:
737 |  |
           case 34:
738 |  |
             ;
739 |  |
             break;
740 |  |
           default:
741 |  |
             jj_la1[13] = jj_gen;
742 |  |
             break label_9;
743 |  |
           }
744 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
745 |  |
           case 27:
746 |  |
             jj_consume_token(27);
747 |  |
               ASTLTNode jjtn001 = new ASTLTNode(this, JJTLTNODE);
748 |  |
               boolean jjtc001 = true;
749 |  |
               jjtree.openNodeScope(jjtn001);
750 |  |
             try {
751 |  |
               AdditiveExpression();
752 |  |
             } catch (Throwable jjte001) {
753 |  |
               if (jjtc001) {
754 |  |
                 jjtree.clearNodeScope(jjtn001);
755 |  |
                 jjtc001 = false;
756 |  |
               } else {
757 |  |
                 jjtree.popNode();
758 |  |
               }
759 |  |
               if (jjte001 instanceof RuntimeException) {
760 |  |
                 {if (true) throw (RuntimeException)jjte001;}
761 |  |
               }
762 |  |
               if (jjte001 instanceof ParseException) {
763 |  |
                 {if (true) throw (ParseException)jjte001;}
764 |  |
               }
765 |  |
               {if (true) throw (Error)jjte001;}
766 |  |
             } finally {
767 |  |
               if (jjtc001) {
768 |  |
                 jjtree.closeNodeScope(jjtn001,  2);
769 |  |
               }
770 |  |
             }
771 |  |
             break;
772 |  |
           case 28:
773 |  |
             jj_consume_token(28);
774 |  |
                ASTLTNode jjtn002 = new ASTLTNode(this, JJTLTNODE);
775 |  |
                boolean jjtc002 = true;
776 |  |
                jjtree.openNodeScope(jjtn002);
777 |  |
             try {
778 |  |
               AdditiveExpression();
779 |  |
             } catch (Throwable jjte002) {
780 |  |
                if (jjtc002) {
781 |  |
                  jjtree.clearNodeScope(jjtn002);
782 |  |
                  jjtc002 = false;
783 |  |
                } else {
784 |  |
                  jjtree.popNode();
785 |  |
                }
786 |  |
                if (jjte002 instanceof RuntimeException) {
787 |  |
                  {if (true) throw (RuntimeException)jjte002;}
788 |  |
                }
789 |  |
                if (jjte002 instanceof ParseException) {
790 |  |
                  {if (true) throw (ParseException)jjte002;}
791 |  |
                }
792 |  |
                {if (true) throw (Error)jjte002;}
793 |  |
             } finally {
794 |  |
                if (jjtc002) {
795 |  |
                  jjtree.closeNodeScope(jjtn002,  2);
796 |  |
                }
797 |  |
             }
798 |  |
             break;
799 |  |
           case 29:
800 |  |
             jj_consume_token(29);
801 |  |
               ASTGTNode jjtn003 = new ASTGTNode(this, JJTGTNODE);
802 |  |
               boolean jjtc003 = true;
803 |  |
               jjtree.openNodeScope(jjtn003);
804 |  |
             try {
805 |  |
               AdditiveExpression();
806 |  |
             } catch (Throwable jjte003) {
807 |  |
               if (jjtc003) {
808 |  |
                 jjtree.clearNodeScope(jjtn003);
809 |  |
                 jjtc003 = false;
810 |  |
               } else {
811 |  |
                 jjtree.popNode();
812 |  |
               }
813 |  |
               if (jjte003 instanceof RuntimeException) {
814 |  |
                 {if (true) throw (RuntimeException)jjte003;}
815 |  |
               }
816 |  |
               if (jjte003 instanceof ParseException) {
817 |  |
                 {if (true) throw (ParseException)jjte003;}
818 |  |
               }
819 |  |
               {if (true) throw (Error)jjte003;}
820 |  |
             } finally {
821 |  |
               if (jjtc003) {
822 |  |
                 jjtree.closeNodeScope(jjtn003,  2);
823 |  |
               }
824 |  |
             }
825 |  |
             break;
826 |  |
           case 30:
827 |  |
             jj_consume_token(30);
828 |  |
                ASTGTNode jjtn004 = new ASTGTNode(this, JJTGTNODE);
829 |  |
                boolean jjtc004 = true;
830 |  |
                jjtree.openNodeScope(jjtn004);
831 |  |
             try {
832 |  |
               AdditiveExpression();
833 |  |
             } catch (Throwable jjte004) {
834 |  |
                if (jjtc004) {
835 |  |
                  jjtree.clearNodeScope(jjtn004);
836 |  |
                  jjtc004 = false;
837 |  |
                } else {
838 |  |
                  jjtree.popNode();
839 |  |
                }
840 |  |
                if (jjte004 instanceof RuntimeException) {
841 |  |
                  {if (true) throw (RuntimeException)jjte004;}
842 |  |
                }
843 |  |
                if (jjte004 instanceof ParseException) {
844 |  |
                  {if (true) throw (ParseException)jjte004;}
845 |  |
                }
846 |  |
                {if (true) throw (Error)jjte004;}
847 |  |
             } finally {
848 |  |
                if (jjtc004) {
849 |  |
                  jjtree.closeNodeScope(jjtn004,  2);
850 |  |
                }
851 |  |
             }
852 |  |
             break;
853 |  |
           case 31:
854 |  |
             jj_consume_token(31);
855 |  |
                ASTLENode jjtn005 = new ASTLENode(this, JJTLENODE);
856 |  |
                boolean jjtc005 = true;
857 |  |
                jjtree.openNodeScope(jjtn005);
858 |  |
             try {
859 |  |
               AdditiveExpression();
860 |  |
             } catch (Throwable jjte005) {
861 |  |
                if (jjtc005) {
862 |  |
                  jjtree.clearNodeScope(jjtn005);
863 |  |
                  jjtc005 = false;
864 |  |
                } else {
865 |  |
                  jjtree.popNode();
866 |  |
                }
867 |  |
                if (jjte005 instanceof RuntimeException) {
868 |  |
                  {if (true) throw (RuntimeException)jjte005;}
869 |  |
                }
870 |  |
                if (jjte005 instanceof ParseException) {
871 |  |
                  {if (true) throw (ParseException)jjte005;}
872 |  |
                }
873 |  |
                {if (true) throw (Error)jjte005;}
874 |  |
             } finally {
875 |  |
                if (jjtc005) {
876 |  |
                  jjtree.closeNodeScope(jjtn005,  2);
877 |  |
                }
878 |  |
             }
879 |  |
             break;
880 |  |
           case 32:
881 |  |
             jj_consume_token(32);
882 |  |
                ASTLENode jjtn006 = new ASTLENode(this, JJTLENODE);
883 |  |
                boolean jjtc006 = true;
884 |  |
                jjtree.openNodeScope(jjtn006);
885 |  |
             try {
886 |  |
               AdditiveExpression();
887 |  |
             } catch (Throwable jjte006) {
888 |  |
                if (jjtc006) {
889 |  |
                  jjtree.clearNodeScope(jjtn006);
890 |  |
                  jjtc006 = false;
891 |  |
                } else {
892 |  |
                  jjtree.popNode();
893 |  |
                }
894 |  |
                if (jjte006 instanceof RuntimeException) {
895 |  |
                  {if (true) throw (RuntimeException)jjte006;}
896 |  |
                }
897 |  |
                if (jjte006 instanceof ParseException) {
898 |  |
                  {if (true) throw (ParseException)jjte006;}
899 |  |
                }
900 |  |
                {if (true) throw (Error)jjte006;}
901 |  |
             } finally {
902 |  |
                if (jjtc006) {
903 |  |
                  jjtree.closeNodeScope(jjtn006,  2);
904 |  |
                }
905 |  |
             }
906 |  |
             break;
907 |  |
           case 33:
908 |  |
             jj_consume_token(33);
909 |  |
                ASTGENode jjtn007 = new ASTGENode(this, JJTGENODE);
910 |  |
                boolean jjtc007 = true;
911 |  |
                jjtree.openNodeScope(jjtn007);
912 |  |
             try {
913 |  |
               AdditiveExpression();
914 |  |
             } catch (Throwable jjte007) {
915 |  |
                if (jjtc007) {
916 |  |
                  jjtree.clearNodeScope(jjtn007);
917 |  |
                  jjtc007 = false;
918 |  |
                } else {
919 |  |
                  jjtree.popNode();
920 |  |
                }
921 |  |
                if (jjte007 instanceof RuntimeException) {
922 |  |
                  {if (true) throw (RuntimeException)jjte007;}
923 |  |
                }
924 |  |
                if (jjte007 instanceof ParseException) {
925 |  |
                  {if (true) throw (ParseException)jjte007;}
926 |  |
                }
927 |  |
                {if (true) throw (Error)jjte007;}
928 |  |
             } finally {
929 |  |
                if (jjtc007) {
930 |  |
                  jjtree.closeNodeScope(jjtn007,  2);
931 |  |
                }
932 |  |
             }
933 |  |
             break;
934 |  |
           case 34:
935 |  |
             jj_consume_token(34);
936 |  |
                ASTGENode jjtn008 = new ASTGENode(this, JJTGENODE);
937 |  |
                boolean jjtc008 = true;
938 |  |
                jjtree.openNodeScope(jjtn008);
939 |  |
             try {
940 |  |
               AdditiveExpression();
941 |  |
             } catch (Throwable jjte008) {
942 |  |
                if (jjtc008) {
943 |  |
                  jjtree.clearNodeScope(jjtn008);
944 |  |
                  jjtc008 = false;
945 |  |
                } else {
946 |  |
                  jjtree.popNode();
947 |  |
                }
948 |  |
                if (jjte008 instanceof RuntimeException) {
949 |  |
                  {if (true) throw (RuntimeException)jjte008;}
950 |  |
                }
951 |  |
                if (jjte008 instanceof ParseException) {
952 |  |
                  {if (true) throw (ParseException)jjte008;}
953 |  |
                }
954 |  |
                {if (true) throw (Error)jjte008;}
955 |  |
             } finally {
956 |  |
                if (jjtc008) {
957 |  |
                  jjtree.closeNodeScope(jjtn008,  2);
958 |  |
                }
959 |  |
             }
960 |  |
             break;
961 |  |
           default:
962 |  |
             jj_la1[14] = jj_gen;
963 |  |
             jj_consume_token(-1);
964 |  |
             throw new ParseException();
965 |  |
           }
966 |  |
         }
967 |  |
       }
968 |  |
969 |  |
       final public void AdditiveExpression() throws ParseException {
970 |  |
         MultiplicativeExpression();
971 |  |
         label_10:
972 |  |
         while (true) {
973 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
974 |  |
           case 35:
975 |  |
           case 36:
976 |  |
             ;
977 |  |
             break;
978 |  |
           default:
979 |  |
             jj_la1[15] = jj_gen;
980 |  |
             break label_10;
981 |  |
           }
982 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
983 |  |
           case 35:
984 |  |
             jj_consume_token(35);
985 |  |
               ASTAddNode jjtn001 = new ASTAddNode(this, JJTADDNODE);
986 |  |
               boolean jjtc001 = true;
987 |  |
               jjtree.openNodeScope(jjtn001);
988 |  |
             try {
989 |  |
               MultiplicativeExpression();
990 |  |
             } catch (Throwable jjte001) {
991 |  |
               if (jjtc001) {
992 |  |
                 jjtree.clearNodeScope(jjtn001);
993 |  |
                 jjtc001 = false;
994 |  |
               } else {
995 |  |
                 jjtree.popNode();
996 |  |
               }
997 |  |
               if (jjte001 instanceof RuntimeException) {
998 |  |
                 {if (true) throw (RuntimeException)jjte001;}
999 |  |
               }
1000 |  |
               if (jjte001 instanceof ParseException) {
1001 |  |
                 {if (true) throw (ParseException)jjte001;}
1002 |  |
               }
1003 |  |
               {if (true) throw (Error)jjte001;}
1004 |  |
             } finally {
1005 |  |
               if (jjtc001) {
1006 |  |
                 jjtree.closeNodeScope(jjtn001,  2);
1007 |  |
               }
1008 |  |
             }
1009 |  |
             break;
1010 |  |
           case 36:
1011 |  |
             jj_consume_token(36);
1012 |  |
               ASTSubtractNode jjtn002 = new ASTSubtractNode(this, JJTSUBTRACTNODE);
1013 |  |
               boolean jjtc002 = true;
1014 |  |
               jjtree.openNodeScope(jjtn002);
1015 |  |
             try {
1016 |  |
               MultiplicativeExpression();
1017 |  |
             } catch (Throwable jjte002) {
1018 |  |
               if (jjtc002) {
1019 |  |
                 jjtree.clearNodeScope(jjtn002);
1020 |  |
                 jjtc002 = false;
1021 |  |
               } else {
1022 |  |
                 jjtree.popNode();
1023 |  |
               }
1024 |  |
               if (jjte002 instanceof RuntimeException) {
1025 |  |
                 {if (true) throw (RuntimeException)jjte002;}
1026 |  |
               }
1027 |  |
               if (jjte002 instanceof ParseException) {
1028 |  |
                 {if (true) throw (ParseException)jjte002;}
1029 |  |
               }
1030 |  |
               {if (true) throw (Error)jjte002;}
1031 |  |
             } finally {
1032 |  |
               if (jjtc002) {
1033 |  |
                 jjtree.closeNodeScope(jjtn002,  2);
1034 |  |
               }
1035 |  |
             }
1036 |  |
             break;
1037 |  |
           default:
1038 |  |
             jj_la1[16] = jj_gen;
1039 |  |
             jj_consume_token(-1);
1040 |  |
             throw new ParseException();
1041 |  |
           }
1042 |  |
         }
1043 |  |
       }
1044 |  |
1045 |  |
       final public void MultiplicativeExpression() throws ParseException {
1046 |  |
         UnaryExpression();
1047 |  |
         label_11:
1048 |  |
         while (true) {
1049 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1050 |  |
           case 37:
1051 |  |
           case 38:
1052 |  |
           case 39:
1053 |  |
           case 40:
1054 |  |
           case 41:
1055 |  |
             ;
1056 |  |
             break;
1057 |  |
           default:
1058 |  |
             jj_la1[17] = jj_gen;
1059 |  |
             break label_11;
1060 |  |
           }
1061 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1062 |  |
           case 37:
1063 |  |
             jj_consume_token(37);
1064 |  |
               ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);
1065 |  |
               boolean jjtc001 = true;
1066 |  |
               jjtree.openNodeScope(jjtn001);
1067 |  |
             try {
1068 |  |
               UnaryExpression();
1069 |  |
             } catch (Throwable jjte001) {
1070 |  |
               if (jjtc001) {
1071 |  |
                 jjtree.clearNodeScope(jjtn001);
1072 |  |
                 jjtc001 = false;
1073 |  |
               } else {
1074 |  |
                 jjtree.popNode();
1075 |  |
               }
1076 |  |
               if (jjte001 instanceof RuntimeException) {
1077 |  |
                 {if (true) throw (RuntimeException)jjte001;}
1078 |  |
               }
1079 |  |
               if (jjte001 instanceof ParseException) {
1080 |  |
                 {if (true) throw (ParseException)jjte001;}
1081 |  |
               }
1082 |  |
               {if (true) throw (Error)jjte001;}
1083 |  |
             } finally {
1084 |  |
               if (jjtc001) {
1085 |  |
                 jjtree.closeNodeScope(jjtn001,  2);
1086 |  |
               }
1087 |  |
             }
1088 |  |
             break;
1089 |  |
           case 38:
1090 |  |
             jj_consume_token(38);
1091 |  |
               ASTDivNode jjtn002 = new ASTDivNode(this, JJTDIVNODE);
1092 |  |
               boolean jjtc002 = true;
1093 |  |
               jjtree.openNodeScope(jjtn002);
1094 |  |
             try {
1095 |  |
               UnaryExpression();
1096 |  |
             } catch (Throwable jjte002) {
1097 |  |
               if (jjtc002) {
1098 |  |
                 jjtree.clearNodeScope(jjtn002);
1099 |  |
                 jjtc002 = false;
1100 |  |
               } else {
1101 |  |
                 jjtree.popNode();
1102 |  |
               }
1103 |  |
               if (jjte002 instanceof RuntimeException) {
1104 |  |
                 {if (true) throw (RuntimeException)jjte002;}
1105 |  |
               }
1106 |  |
               if (jjte002 instanceof ParseException) {
1107 |  |
                 {if (true) throw (ParseException)jjte002;}
1108 |  |
               }
1109 |  |
               {if (true) throw (Error)jjte002;}
1110 |  |
             } finally {
1111 |  |
               if (jjtc002) {
1112 |  |
                 jjtree.closeNodeScope(jjtn002,  2);
1113 |  |
               }
1114 |  |
             }
1115 |  |
             break;
1116 |  |
           case 39:
1117 |  |
             jj_consume_token(39);
1118 |  |
                 ASTDivNode jjtn003 = new ASTDivNode(this, JJTDIVNODE);
1119 |  |
                 boolean jjtc003 = true;
1120 |  |
                 jjtree.openNodeScope(jjtn003);
1121 |  |
             try {
1122 |  |
               UnaryExpression();
1123 |  |
             } catch (Throwable jjte003) {
1124 |  |
                 if (jjtc003) {
1125 |  |
                   jjtree.clearNodeScope(jjtn003);
1126 |  |
                   jjtc003 = false;
1127 |  |
                 } else {
1128 |  |
                   jjtree.popNode();
1129 |  |
                 }
1130 |  |
                 if (jjte003 instanceof RuntimeException) {
1131 |  |
                   {if (true) throw (RuntimeException)jjte003;}
1132 |  |
                 }
1133 |  |
                 if (jjte003 instanceof ParseException) {
1134 |  |
                   {if (true) throw (ParseException)jjte003;}
1135 |  |
                 }
1136 |  |
                 {if (true) throw (Error)jjte003;}
1137 |  |
             } finally {
1138 |  |
                 if (jjtc003) {
1139 |  |
                   jjtree.closeNodeScope(jjtn003,  2);
1140 |  |
                 }
1141 |  |
             }
1142 |  |
             break;
1143 |  |
           case 40:
1144 |  |
             jj_consume_token(40);
1145 |  |
               ASTModNode jjtn004 = new ASTModNode(this, JJTMODNODE);
1146 |  |
               boolean jjtc004 = true;
1147 |  |
               jjtree.openNodeScope(jjtn004);
1148 |  |
             try {
1149 |  |
               UnaryExpression();
1150 |  |
             } catch (Throwable jjte004) {
1151 |  |
               if (jjtc004) {
1152 |  |
                 jjtree.clearNodeScope(jjtn004);
1153 |  |
                 jjtc004 = false;
1154 |  |
               } else {
1155 |  |
                 jjtree.popNode();
1156 |  |
               }
1157 |  |
               if (jjte004 instanceof RuntimeException) {
1158 |  |
                 {if (true) throw (RuntimeException)jjte004;}
1159 |  |
               }
1160 |  |
               if (jjte004 instanceof ParseException) {
1161 |  |
                 {if (true) throw (ParseException)jjte004;}
1162 |  |
               }
1163 |  |
               {if (true) throw (Error)jjte004;}
1164 |  |
             } finally {
1165 |  |
               if (jjtc004) {
1166 |  |
                 jjtree.closeNodeScope(jjtn004,  2);
1167 |  |
               }
1168 |  |
             }
1169 |  |
             break;
1170 |  |
           case 41:
1171 |  |
             jj_consume_token(41);
1172 |  |
                 ASTModNode jjtn005 = new ASTModNode(this, JJTMODNODE);
1173 |  |
                 boolean jjtc005 = true;
1174 |  |
                 jjtree.openNodeScope(jjtn005);
1175 |  |
             try {
1176 |  |
               UnaryExpression();
1177 |  |
             } catch (Throwable jjte005) {
1178 |  |
                 if (jjtc005) {
1179 |  |
                   jjtree.clearNodeScope(jjtn005);
1180 |  |
                   jjtc005 = false;
1181 |  |
                 } else {
1182 |  |
                   jjtree.popNode();
1183 |  |
                 }
1184 |  |
                 if (jjte005 instanceof RuntimeException) {
1185 |  |
                   {if (true) throw (RuntimeException)jjte005;}
1186 |  |
                 }
1187 |  |
                 if (jjte005 instanceof ParseException) {
1188 |  |
                   {if (true) throw (ParseException)jjte005;}
1189 |  |
                 }
1190 |  |
                 {if (true) throw (Error)jjte005;}
1191 |  |
             } finally {
1192 |  |
                 if (jjtc005) {
1193 |  |
                   jjtree.closeNodeScope(jjtn005,  2);
1194 |  |
                 }
1195 |  |
             }
1196 |  |
             break;
1197 |  |
           default:
1198 |  |
             jj_la1[18] = jj_gen;
1199 |  |
             jj_consume_token(-1);
1200 |  |
             throw new ParseException();
1201 |  |
           }
1202 |  |
         }
1203 |  |
       }
1204 |  |
1205 |  |
       final public void UnaryExpression() throws ParseException {
1206 |  |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1207 |  |
         case 36:
1208 |  |
           jj_consume_token(36);
1209 |  |
             ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(this, JJTUNARYMINUSNODE);
1210 |  |
             boolean jjtc001 = true;
1211 |  |
             jjtree.openNodeScope(jjtn001);
1212 |  |
           try {
1213 |  |
             UnaryExpression();
1214 |  |
           } catch (Throwable jjte001) {
1215 |  |
             if (jjtc001) {
1216 |  |
               jjtree.clearNodeScope(jjtn001);
1217 |  |
               jjtc001 = false;
1218 |  |
             } else {
1219 |  |
               jjtree.popNode();
1220 |  |
             }
1221 |  |
             if (jjte001 instanceof RuntimeException) {
1222 |  |
               {if (true) throw (RuntimeException)jjte001;}
1223 |  |
             }
1224 |  |
             if (jjte001 instanceof ParseException) {
1225 |  |
               {if (true) throw (ParseException)jjte001;}
1226 |  |
             }
1227 |  |
             {if (true) throw (Error)jjte001;}
1228 |  |
           } finally {
1229 |  |
             if (jjtc001) {
1230 |  |
               jjtree.closeNodeScope(jjtn001,  1);
1231 |  |
             }
1232 |  |
           }
1233 |  |
           break;
1234 |  |
         case 42:
1235 |  |
           jj_consume_token(42);
1236 |  |
             ASTBitwiseComplNode jjtn002 = new ASTBitwiseComplNode(this, JJTBITWISECOMPLNODE);
1237 |  |
             boolean jjtc002 = true;
1238 |  |
             jjtree.openNodeScope(jjtn002);
1239 |  |
           try {
1240 |  |
             UnaryExpression();
1241 |  |
           } catch (Throwable jjte002) {
1242 |  |
             if (jjtc002) {
1243 |  |
               jjtree.clearNodeScope(jjtn002);
1244 |  |
               jjtc002 = false;
1245 |  |
             } else {
1246 |  |
               jjtree.popNode();
1247 |  |
             }
1248 |  |
             if (jjte002 instanceof RuntimeException) {
1249 |  |
               {if (true) throw (RuntimeException)jjte002;}
1250 |  |
             }
1251 |  |
             if (jjte002 instanceof ParseException) {
1252 |  |
               {if (true) throw (ParseException)jjte002;}
1253 |  |
             }
1254 |  |
             {if (true) throw (Error)jjte002;}
1255 |  |
           } finally {
1256 |  |
             if (jjtc002) {
1257 |  |
               jjtree.closeNodeScope(jjtn002,  1);
1258 |  |
             }
1259 |  |
           }
1260 |  |
           break;
1261 |  |
         case 43:
1262 |  |
           jj_consume_token(43);
1263 |  |
             ASTNotNode jjtn003 = new ASTNotNode(this, JJTNOTNODE);
1264 |  |
             boolean jjtc003 = true;
1265 |  |
             jjtree.openNodeScope(jjtn003);
1266 |  |
           try {
1267 |  |
             UnaryExpression();
1268 |  |
           } catch (Throwable jjte003) {
1269 |  |
             if (jjtc003) {
1270 |  |
               jjtree.clearNodeScope(jjtn003);
1271 |  |
               jjtc003 = false;
1272 |  |
             } else {
1273 |  |
               jjtree.popNode();
1274 |  |
             }
1275 |  |
             if (jjte003 instanceof RuntimeException) {
1276 |  |
               {if (true) throw (RuntimeException)jjte003;}
1277 |  |
             }
1278 |  |
             if (jjte003 instanceof ParseException) {
1279 |  |
               {if (true) throw (ParseException)jjte003;}
1280 |  |
             }
1281 |  |
             {if (true) throw (Error)jjte003;}
1282 |  |
           } finally {
1283 |  |
             if (jjtc003) {
1284 |  |
               jjtree.closeNodeScope(jjtn003,  1);
1285 |  |
             }
1286 |  |
           }
1287 |  |
           break;
1288 |  |
         case 44:
1289 |  |
           jj_consume_token(44);
1290 |  |
               ASTNotNode jjtn004 = new ASTNotNode(this, JJTNOTNODE);
1291 |  |
               boolean jjtc004 = true;
1292 |  |
               jjtree.openNodeScope(jjtn004);
1293 |  |
           try {
1294 |  |
             UnaryExpression();
1295 |  |
           } catch (Throwable jjte004) {
1296 |  |
               if (jjtc004) {
1297 |  |
                 jjtree.clearNodeScope(jjtn004);
1298 |  |
                 jjtc004 = false;
1299 |  |
               } else {
1300 |  |
                 jjtree.popNode();
1301 |  |
               }
1302 |  |
               if (jjte004 instanceof RuntimeException) {
1303 |  |
                 {if (true) throw (RuntimeException)jjte004;}
1304 |  |
               }
1305 |  |
               if (jjte004 instanceof ParseException) {
1306 |  |
                 {if (true) throw (ParseException)jjte004;}
1307 |  |
               }
1308 |  |
               {if (true) throw (Error)jjte004;}
1309 |  |
           } finally {
1310 |  |
               if (jjtc004) {
1311 |  |
                 jjtree.closeNodeScope(jjtn004,  1);
1312 |  |
               }
1313 |  |
           }
1314 |  |
           break;
1315 |  |
         case INTEGER_LITERAL:
1316 |  |
         case FLOAT_LITERAL:
1317 |  |
         case 11:
1318 |  |
         case 12:
1319 |  |
         case 14:
1320 |  |
         case 45:
1321 |  |
         case 46:
1322 |  |
         case 47:
1323 |  |
         case IDENTIFIER:
1324 |  |
         case STRING_LITERAL:
1325 |  |
           PrimaryExpression();
1326 |  |
           break;
1327 |  |
         default:
1328 |  |
           jj_la1[19] = jj_gen;
1329 |  |
           jj_consume_token(-1);
1330 |  |
           throw new ParseException();
1331 |  |
         }
1332 |  |
       }
1333 |  |
1334 |  |
       final public void PrimaryExpression() throws ParseException {
1335 |  |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1336 |  |
         case INTEGER_LITERAL:
1337 |  |
         case FLOAT_LITERAL:
1338 |  |
         case 45:
1339 |  |
         case 46:
1340 |  |
         case 47:
1341 |  |
         case STRING_LITERAL:
1342 |  |
           Literal();
1343 |  |
           break;
1344 |  |
         case IDENTIFIER:
1345 |  |
           Reference();
1346 |  |
           break;
1347 |  |
         case 12:
1348 |  |
           jj_consume_token(12);
1349 |  |
           Expression();
1350 |  |
           jj_consume_token(13);
1351 |  |
           break;
1352 |  |
         case 11:
1353 |  |
           EmptyFunction();
1354 |  |
           break;
1355 |  |
         case 14:
1356 |  |
           SizeFunction();
1357 |  |
           break;
1358 |  |
         default:
1359 |  |
           jj_la1[20] = jj_gen;
1360 |  |
           jj_consume_token(-1);
1361 |  |
           throw new ParseException();
1362 |  |
         }
1363 |  |
       }
1364 |  |
1365 |  |
       final public void Literal() throws ParseException {
1366 |  |
        Token t;
1367 |  |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1368 |  |
         case INTEGER_LITERAL:
1369 |  |
           IntegerLiteral();
1370 |  |
           break;
1371 |  |
         case FLOAT_LITERAL:
1372 |  |
           FloatLiteral();
1373 |  |
           break;
1374 |  |
         case 46:
1375 |  |
         case 47:
1376 |  |
           BooleanLiteral();
1377 |  |
           break;
1378 |  |
         case STRING_LITERAL:
1379 |  |
           StringLiteral();
1380 |  |
           break;
1381 |  |
         case 45:
1382 |  |
           NullLiteral();
1383 |  |
           break;
1384 |  |
         default:
1385 |  |
           jj_la1[21] = jj_gen;
1386 |  |
           jj_consume_token(-1);
1387 |  |
           throw new ParseException();
1388 |  |
         }
1389 |  |
       }
1390 |  |
1391 |  |
       final public void NullLiteral() throws ParseException {
1392 |  |
                           /*@bgen(jjtree) NullLiteral */
1393 |  |
       ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
1394 |  |
       boolean jjtc000 = true;
1395 |  |
       jjtree.openNodeScope(jjtn000);
1396 |  |
         try {
1397 |  |
           jj_consume_token(45);
1398 |  |
         } finally {
1399 |  |
           if (jjtc000) {
1400 |  |
             jjtree.closeNodeScope(jjtn000, true);
1401 |  |
           }
1402 |  |
         }
1403 |  |
       }
1404 |  |
1405 |  |
       final public void BooleanLiteral() throws ParseException {
1406 |  |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1407 |  |
         case 46:
1408 |  |
         ASTTrueNode jjtn001 = new ASTTrueNode(this, JJTTRUENODE);
1409 |  |
         boolean jjtc001 = true;
1410 |  |
         jjtree.openNodeScope(jjtn001);
1411 |  |
           try {
1412 |  |
             jj_consume_token(46);
1413 |  |
           } finally {
1414 |  |
         if (jjtc001) {
1415 |  |
           jjtree.closeNodeScope(jjtn001, true);
1416 |  |
         }
1417 |  |
           }
1418 |  |
           break;
1419 |  |
         case 47:
1420 |  |
         ASTFalseNode jjtn002 = new ASTFalseNode(this, JJTFALSENODE);
1421 |  |
         boolean jjtc002 = true;
1422 |  |
         jjtree.openNodeScope(jjtn002);
1423 |  |
           try {
1424 |  |
             jj_consume_token(47);
1425 |  |
           } finally {
1426 |  |
         if (jjtc002) {
1427 |  |
           jjtree.closeNodeScope(jjtn002, true);
1428 |  |
         }
1429 |  |
           }
1430 |  |
           break;
1431 |  |
         default:
1432 |  |
           jj_la1[22] = jj_gen;
1433 |  |
           jj_consume_token(-1);
1434 |  |
           throw new ParseException();
1435 |  |
         }
1436 |  |
       }
1437 |  |
1438 |  |
       final public void IntegerLiteral() throws ParseException {
1439 |  |
      /*@bgen(jjtree) IntegerLiteral */
1440 |  |
       ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(this, JJTINTEGERLITERAL);
1441 |  |
       boolean jjtc000 = true;
1442 |  |
       jjtree.openNodeScope(jjtn000);Token t;
1443 |  |
         try {
1444 |  |
           t = jj_consume_token(INTEGER_LITERAL);
1445 |  |
           jjtree.closeNodeScope(jjtn000, true);
1446 |  |
           jjtc000 = false;
1447 |  |
            jjtn000.val = Integer.valueOf(t.image);
1448 |  |
         } finally {
1449 |  |
        if (jjtc000) {
1450 |  |
          jjtree.closeNodeScope(jjtn000, true);
1451 |  |
        }
1452 |  |
         }
1453 |  |
       }
1454 |  |
1455 |  |
       final public void FloatLiteral() throws ParseException {
1456 |  |
      /*@bgen(jjtree) FloatLiteral */
1457 |  |
       ASTFloatLiteral jjtn000 = new ASTFloatLiteral(this, JJTFLOATLITERAL);
1458 |  |
       boolean jjtc000 = true;
1459 |  |
       jjtree.openNodeScope(jjtn000);Token t;
1460 |  |
         try {
1461 |  |
           t = jj_consume_token(FLOAT_LITERAL);
1462 |  |
           jjtree.closeNodeScope(jjtn000, true);
1463 |  |
           jjtc000 = false;
1464 |  |
            jjtn000.val = Float.valueOf(t.image);
1465 |  |
         } finally {
1466 |  |
        if (jjtc000) {
1467 |  |
          jjtree.closeNodeScope(jjtn000, true);
1468 |  |
        }
1469 |  |
         }
1470 |  |
       }
1471 |  |
1472 |  |
       final public void StringLiteral() throws ParseException {
1473 |  |
      /*@bgen(jjtree) StringLiteral */
1474 |  |
        ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
1475 |  |
        boolean jjtc000 = true;
1476 |  |
        jjtree.openNodeScope(jjtn000);Token t;
1477 |  |
         try {
1478 |  |
           t = jj_consume_token(STRING_LITERAL);
1479 |  |
           jjtree.closeNodeScope(jjtn000, true);
1480 |  |
           jjtc000 = false;
1481 |  |
            jjtn000.literal = t.image.substring(1,t.image.length()-1);
1482 |  |
         } finally {
1483 |  |
        if (jjtc000) {
1484 |  |
          jjtree.closeNodeScope(jjtn000, true);
1485 |  |
        }
1486 |  |
         }
1487 |  |
       }
1488 |  |
1489 |  |
     /*
1490 |  |
      * Statement syntax follows.
1491 |  |
      */
1492 |  |
       final public void Statement() throws ParseException {
1493 |  |
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1494 |  |
         case 48:
1495 |  |
           jj_consume_token(48);
1496 |  |
           break;
1497 |  |
         case 9:
1498 |  |
           Block();
1499 |  |
           break;
1500 |  |
         default:
1501 |  |
           jj_la1[23] = jj_gen;
1502 |  |
           if (jj_2_2(2147483647)) {
1503 |  |
             ReferenceExpression();
1504 |  |
           } else if (jj_2_3(2147483647)) {
1505 |  |
             StatementExpression();
1506 |  |
           } else {
1507 |  |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1508 |  |
             case INTEGER_LITERAL:
1509 |  |
             case FLOAT_LITERAL:
1510 |  |
             case 11:
1511 |  |
             case 12:
1512 |  |
             case 14:
1513 |  |
             case 36:
1514 |  |
             case 42:
1515 |  |
             case 43:
1516 |  |
             case 44:
1517 |  |
             case 45:
1518 |  |
             case 46:
1519 |  |
             case 47:
1520 |  |
             case IDENTIFIER:
1521 |  |
             case STRING_LITERAL:
1522 |  |
               ExpressionExpression();
1523 |  |
               break;
1524 |  |
             case 49:
1525 |  |
               IfStatement();
1526 |  |
               break;
1527 |  |
             case 52:
1528 |  |
               ForeachStatement();
1529 |  |
               break;
1530 |  |
             case 51:
1531 |  |
               WhileStatement();
1532 |  |
               break;
1533 |  |
             default:
1534 |  |
               jj_la1[24] = jj_gen;
1535 |  |
               jj_consume_token(-1);
1536 |  |
               throw new ParseException();
1537 |  |
             }
1538 |  |
           }
1539 |  |
         }
1540 |  |
       }
1541 |  |
1542 |  |
       final public void ExpressionExpression() throws ParseException {
1543 |  |
                                    /*@bgen(jjtree) ExpressionExpression */
1544 |  |
       ASTExpressionExpression jjtn000 = new ASTExpressionExpression(this, JJTEXPRESSIONEXPRESSION);
1545 |  |
       boolean jjtc000 = true;
1546 |  |
       jjtree.openNodeScope(jjtn000);
1547 |  |
         try {
1548 |  |
           Expression();
1549 |  |
           jj_consume_token(48);
1550 |  |
         } catch (Throwable jjte000) {
1551 |  |
           if (jjtc000) {
1552 |  |
             jjtree.clearNodeScope(jjtn000);
1553 |  |
             jjtc000 = false;
1554 |  |
           } else {
1555 |  |
             jjtree.popNode();
1556 |  |
           }
1557 |  |
           if (jjte000 instanceof RuntimeException) {
1558 |  |
             {if (true) throw (RuntimeException)jjte000;}
1559 |  |
           }
1560 |  |
           if (jjte000 instanceof ParseException) {
1561 |  |
             {if (true) throw (ParseException)jjte000;}
1562 |  |
           }
1563 |  |
           {if (true) throw (Error)jjte000;}
1564 |  |
         } finally {
1565 |  |
           if (jjtc000) {
1566 |  |
             jjtree.closeNodeScope(jjtn000, true);
1567 |  |
           }
1568 |  |
         }
1569 |  |
       }
1570 |  |
1571 |  |
       final public void StatementExpression() throws ParseException {
1572 |  |
                                   /*@bgen(jjtree) StatementExpression */
1573 |  |
       ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
1574 |  |
       boolean jjtc000 = true;
1575 |  |
       jjtree.openNodeScope(jjtn000);
1576 |  |
         try {
1577 |  |
           Assignment();
1578 |  |
           jj_consume_token(48);
1579 |  |
         } catch (Throwable jjte000) {
1580 |  |
         if (jjtc000) {
1581 |  |
           jjtree.clearNodeScope(jjtn000);
1582 |  |
           jjtc000 = false;
1583 |  |
         } else {
1584 |  |
           jjtree.popNode();
1585 |  |
         }
1586 |  |
         if (jjte000 instanceof RuntimeException) {
1587 |  |
           {if (true) throw (RuntimeException)jjte000;}
1588 |  |
         }
1589 |  |
         if (jjte000 instanceof ParseException) {
1590 |  |
           {if (true) throw (ParseException)jjte000;}
1591 |  |
         }
1592 |  |
         {if (true) throw (Error)jjte000;}
1593 |  |
         } finally {
1594 |  |
         if (jjtc000) {
1595 |  |
           jjtree.closeNodeScope(jjtn000, true);
1596 |  |
         }
1597 |  |
         }
1598 |  |
       }
1599 |  |
1600 |  |
       final public void ReferenceExpression() throws ParseException {
1601 |  |
                                   /*@bgen(jjtree) ReferenceExpression */
1602 |  |
       ASTReferenceExpression jjtn000 = new ASTReferenceExpression(this, JJTREFERENCEEXPRESSION);
1603 |  |
       boolean jjtc000 = true;
1604 |  |
       jjtree.openNodeScope(jjtn000);
1605 |  |
         try {
1606 |  |
           Reference();
1607 |  |
           jj_consume_token(48);
1608 |  |
         } catch (Throwable jjte000) {
1609 |  |
         if (jjtc000) {
1610 |  |
           jjtree.clearNodeScope(jjtn000);
1611 |  |
           jjtc000 = false;
1612 |  |
         } else {
1613 |  |
           jjtree.popNode();
1614 |  |
         }
1615 |  |
         if (jjte000 instanceof RuntimeException) {
1616 |  |
           {if (true) throw (RuntimeException)jjte000;}
1617 |  |
         }
1618 |  |
         if (jjte000 instanceof ParseException) {
1619 |  |
           {if (true) throw (ParseException)jjte000;}
1620 |  |
         }
1621 |  |
         {if (true) throw (Error)jjte000;}
1622 |  |
         } finally {
1623 |  |
         if (jjtc000) {
1624 |  |
           jjtree.closeNodeScope(jjtn000, true);
1625 |  |
         }
1626 |  |
         }
1627 |  |
       }
1628 |  |
1629 |  |
       final public void IfStatement() throws ParseException {
1630 |  |
                          /*@bgen(jjtree) IfStatement */
1631 |  |
       ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
1632 |  |
       boolean jjtc000 = true;
1633 |  |
       jjtree.openNodeScope(jjtn000);
1634 |  |
         try {
1635 |  |
           jj_consume_token(49);
1636 |  |
           jj_consume_token(12);
1637 |  |
           Expression();
1638 |  |
           jj_consume_token(13);
1639 |  |
           Statement();
1640 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1641 |  |
           case 50:
1642 |  |
             jj_consume_token(50);
1643 |  |
             Statement();
1644 |  |
             break;
1645 |  |
           default:
1646 |  |
             jj_la1[25] = jj_gen;
1647 |  |
             ;
1648 |  |
           }
1649 |  |
         } catch (Throwable jjte000) {
1650 |  |
         if (jjtc000) {
1651 |  |
           jjtree.clearNodeScope(jjtn000);
1652 |  |
           jjtc000 = false;
1653 |  |
         } else {
1654 |  |
           jjtree.popNode();
1655 |  |
         }
1656 |  |
         if (jjte000 instanceof RuntimeException) {
1657 |  |
           {if (true) throw (RuntimeException)jjte000;}
1658 |  |
         }
1659 |  |
         if (jjte000 instanceof ParseException) {
1660 |  |
           {if (true) throw (ParseException)jjte000;}
1661 |  |
         }
1662 |  |
         {if (true) throw (Error)jjte000;}
1663 |  |
         } finally {
1664 |  |
         if (jjtc000) {
1665 |  |
           jjtree.closeNodeScope(jjtn000, true);
1666 |  |
         }
1667 |  |
         }
1668 |  |
       }
1669 |  |
1670 |  |
       final public void WhileStatement() throws ParseException {
1671 |  |
      /*@bgen(jjtree) WhileStatement */
1672 |  |
       ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
1673 |  |
       boolean jjtc000 = true;
1674 |  |
       jjtree.openNodeScope(jjtn000);
1675 |  |
         try {
1676 |  |
           jj_consume_token(51);
1677 |  |
           jj_consume_token(12);
1678 |  |
           Expression();
1679 |  |
           jj_consume_token(13);
1680 |  |
           Statement();
1681 |  |
         } catch (Throwable jjte000) {
1682 |  |
         if (jjtc000) {
1683 |  |
           jjtree.clearNodeScope(jjtn000);
1684 |  |
           jjtc000 = false;
1685 |  |
         } else {
1686 |  |
           jjtree.popNode();
1687 |  |
         }
1688 |  |
         if (jjte000 instanceof RuntimeException) {
1689 |  |
           {if (true) throw (RuntimeException)jjte000;}
1690 |  |
         }
1691 |  |
         if (jjte000 instanceof ParseException) {
1692 |  |
           {if (true) throw (ParseException)jjte000;}
1693 |  |
         }
1694 |  |
         {if (true) throw (Error)jjte000;}
1695 |  |
         } finally {
1696 |  |
         if (jjtc000) {
1697 |  |
           jjtree.closeNodeScope(jjtn000, true);
1698 |  |
         }
1699 |  |
         }
1700 |  |
       }
1701 |  |
1702 |  |
       final public void ForeachStatement() throws ParseException {
1703 |  |
      /*@bgen(jjtree) ForeachStatement */
1704 |  |
       ASTForeachStatement jjtn000 = new ASTForeachStatement(this, JJTFOREACHSTATEMENT);
1705 |  |
       boolean jjtc000 = true;
1706 |  |
       jjtree.openNodeScope(jjtn000);
1707 |  |
         try {
1708 |  |
           jj_consume_token(52);
1709 |  |
           jj_consume_token(12);
1710 |  |
           Reference();
1711 |  |
           jj_consume_token(53);
1712 |  |
           Reference();
1713 |  |
           jj_consume_token(13);
1714 |  |
           Statement();
1715 |  |
         } catch (Throwable jjte000) {
1716 |  |
         if (jjtc000) {
1717 |  |
           jjtree.clearNodeScope(jjtn000);
1718 |  |
           jjtc000 = false;
1719 |  |
         } else {
1720 |  |
           jjtree.popNode();
1721 |  |
         }
1722 |  |
         if (jjte000 instanceof RuntimeException) {
1723 |  |
           {if (true) throw (RuntimeException)jjte000;}
1724 |  |
         }
1725 |  |
         if (jjte000 instanceof ParseException) {
1726 |  |
           {if (true) throw (ParseException)jjte000;}
1727 |  |
         }
1728 |  |
         {if (true) throw (Error)jjte000;}
1729 |  |
         } finally {
1730 |  |
         if (jjtc000) {
1731 |  |
           jjtree.closeNodeScope(jjtn000, true);
1732 |  |
         }
1733 |  |
         }
1734 |  |
       }
1735 |  |
1736 |  |
       final public void Method() throws ParseException {
1737 |  |
                      /*@bgen(jjtree) Method */
1738 |  |
       ASTMethod jjtn000 = new ASTMethod(this, JJTMETHOD);
1739 |  |
       boolean jjtc000 = true;
1740 |  |
       jjtree.openNodeScope(jjtn000);
1741 |  |
         try {
1742 |  |
           Identifier();
1743 |  |
           jj_consume_token(12);
1744 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1745 |  |
           case INTEGER_LITERAL:
1746 |  |
           case FLOAT_LITERAL:
1747 |  |
           case 11:
1748 |  |
           case 12:
1749 |  |
           case 14:
1750 |  |
           case 36:
1751 |  |
           case 42:
1752 |  |
           case 43:
1753 |  |
           case 44:
1754 |  |
           case 45:
1755 |  |
           case 46:
1756 |  |
           case 47:
1757 |  |
           case IDENTIFIER:
1758 |  |
           case STRING_LITERAL:
1759 |  |
             Parameter();
1760 |  |
             label_12:
1761 |  |
             while (true) {
1762 |  |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1763 |  |
               case 54:
1764 |  |
                 ;
1765 |  |
                 break;
1766 |  |
               default:
1767 |  |
                 jj_la1[26] = jj_gen;
1768 |  |
                 break label_12;
1769 |  |
               }
1770 |  |
               jj_consume_token(54);
1771 |  |
               Parameter();
1772 |  |
             }
1773 |  |
             break;
1774 |  |
           default:
1775 |  |
             jj_la1[27] = jj_gen;
1776 |  |
             ;
1777 |  |
           }
1778 |  |
           jj_consume_token(13);
1779 |  |
         } catch (Throwable jjte000) {
1780 |  |
          if (jjtc000) {
1781 |  |
            jjtree.clearNodeScope(jjtn000);
1782 |  |
            jjtc000 = false;
1783 |  |
          } else {
1784 |  |
            jjtree.popNode();
1785 |  |
          }
1786 |  |
          if (jjte000 instanceof RuntimeException) {
1787 |  |
            {if (true) throw (RuntimeException)jjte000;}
1788 |  |
          }
1789 |  |
          if (jjte000 instanceof ParseException) {
1790 |  |
            {if (true) throw (ParseException)jjte000;}
1791 |  |
          }
1792 |  |
          {if (true) throw (Error)jjte000;}
1793 |  |
         } finally {
1794 |  |
          if (jjtc000) {
1795 |  |
            jjtree.closeNodeScope(jjtn000, true);
1796 |  |
          }
1797 |  |
         }
1798 |  |
       }
1799 |  |
1800 |  |
       final public void ArrayAccess() throws ParseException {
1801 |  |
                           /*@bgen(jjtree) ArrayAccess */
1802 |  |
       ASTArrayAccess jjtn000 = new ASTArrayAccess(this, JJTARRAYACCESS);
1803 |  |
       boolean jjtc000 = true;
1804 |  |
       jjtree.openNodeScope(jjtn000);
1805 |  |
         try {
1806 |  |
           Identifier();
1807 |  |
           label_13:
1808 |  |
           while (true) {
1809 |  |
             jj_consume_token(55);
1810 |  |
             if (jj_2_4(3)) {
1811 |  |
               Expression();
1812 |  |
             } else {
1813 |  |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1814 |  |
               case INTEGER_LITERAL:
1815 |  |
                 IntegerLiteral();
1816 |  |
                 break;
1817 |  |
               case IDENTIFIER:
1818 |  |
                 Reference();
1819 |  |
                 break;
1820 |  |
               default:
1821 |  |
                 jj_la1[28] = jj_gen;
1822 |  |
                 jj_consume_token(-1);
1823 |  |
                 throw new ParseException();
1824 |  |
               }
1825 |  |
             }
1826 |  |
             jj_consume_token(56);
1827 |  |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1828 |  |
             case 55:
1829 |  |
               ;
1830 |  |
               break;
1831 |  |
             default:
1832 |  |
               jj_la1[29] = jj_gen;
1833 |  |
               break label_13;
1834 |  |
             }
1835 |  |
           }
1836 |  |
         } catch (Throwable jjte000) {
1837 |  |
           if (jjtc000) {
1838 |  |
             jjtree.clearNodeScope(jjtn000);
1839 |  |
             jjtc000 = false;
1840 |  |
           } else {
1841 |  |
             jjtree.popNode();
1842 |  |
           }
1843 |  |
           if (jjte000 instanceof RuntimeException) {
1844 |  |
             {if (true) throw (RuntimeException)jjte000;}
1845 |  |
           }
1846 |  |
           if (jjte000 instanceof ParseException) {
1847 |  |
             {if (true) throw (ParseException)jjte000;}
1848 |  |
           }
1849 |  |
           {if (true) throw (Error)jjte000;}
1850 |  |
         } finally {
1851 |  |
           if (jjtc000) {
1852 |  |
             jjtree.closeNodeScope(jjtn000, true);
1853 |  |
           }
1854 |  |
         }
1855 |  |
       }
1856 |  |
1857 |  |
       final public void SizeMethod() throws ParseException {
1858 |  |
                          /*@bgen(jjtree) SizeMethod */
1859 |  |
       ASTSizeMethod jjtn000 = new ASTSizeMethod(this, JJTSIZEMETHOD);
1860 |  |
       boolean jjtc000 = true;
1861 |  |
       jjtree.openNodeScope(jjtn000);
1862 |  |
         try {
1863 |  |
           jj_consume_token(14);
1864 |  |
           jj_consume_token(12);
1865 |  |
           jj_consume_token(13);
1866 |  |
         } finally {
1867 |  |
               if (jjtc000) {
1868 |  |
                 jjtree.closeNodeScope(jjtn000, true);
1869 |  |
               }
1870 |  |
         }
1871 |  |
       }
1872 |  |
1873 |  |
       final public void Reference() throws ParseException {
1874 |  |
                         /*@bgen(jjtree) Reference */
1875 |  |
       ASTReference jjtn000 = new ASTReference(this, JJTREFERENCE);
1876 |  |
       boolean jjtc000 = true;
1877 |  |
       jjtree.openNodeScope(jjtn000);
1878 |  |
         try {
1879 |  |
           if (jj_2_5(2147483647)) {
1880 |  |
             ArrayAccess();
1881 |  |
           } else {
1882 |  |
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1883 |  |
             case IDENTIFIER:
1884 |  |
               Identifier();
1885 |  |
               break;
1886 |  |
             default:
1887 |  |
               jj_la1[30] = jj_gen;
1888 |  |
               jj_consume_token(-1);
1889 |  |
               throw new ParseException();
1890 |  |
             }
1891 |  |
           }
1892 |  |
           label_14:
1893 |  |
           while (true) {
1894 |  |
             if (jj_2_6(2)) {
1895 |  |
               ;
1896 |  |
             } else {
1897 |  |
               break label_14;
1898 |  |
             }
1899 |  |
             jj_consume_token(57);
1900 |  |
             if (jj_2_8(2147483647)) {
1901 |  |
               ArrayAccess();
1902 |  |
             } else {
1903 |  |
               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1904 |  |
               case INTEGER_LITERAL:
1905 |  |
               case 14:
1906 |  |
               case IDENTIFIER:
1907 |  |
                 if (jj_2_7(3)) {
1908 |  |
                   Method();
1909 |  |
                 } else {
1910 |  |
                   switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1911 |  |
                   case 14:
1912 |  |
                     SizeMethod();
1913 |  |
                     break;
1914 |  |
                   case IDENTIFIER:
1915 |  |
                     Identifier();
1916 |  |
                     break;
1917 |  |
                   case INTEGER_LITERAL:
1918 |  |
                     IntegerLiteral();
1919 |  |
                     break;
1920 |  |
                   default:
1921 |  |
                     jj_la1[31] = jj_gen;
1922 |  |
                     jj_consume_token(-1);
1923 |  |
                     throw new ParseException();
1924 |  |
                   }
1925 |  |
                 }
1926 |  |
                 break;
1927 |  |
               default:
1928 |  |
                 jj_la1[32] = jj_gen;
1929 |  |
                 jj_consume_token(-1);
1930 |  |
                 throw new ParseException();
1931 |  |
               }
1932 |  |
             }
1933 |  |
           }
1934 |  |
         } catch (Throwable jjte000) {
1935 |  |
         if (jjtc000) {
1936 |  |
           jjtree.clearNodeScope(jjtn000);
1937 |  |
           jjtc000 = false;
1938 |  |
         } else {
1939 |  |
           jjtree.popNode();
1940 |  |
         }
1941 |  |
         if (jjte000 instanceof RuntimeException) {
1942 |  |
           {if (true) throw (RuntimeException)jjte000;}
1943 |  |
         }
1944 |  |
         if (jjte000 instanceof ParseException) {
1945 |  |
           {if (true) throw (ParseException)jjte000;}
1946 |  |
         }
1947 |  |
         {if (true) throw (Error)jjte000;}
1948 |  |
         } finally {
1949 |  |
         if (jjtc000) {
1950 |  |
           jjtree.closeNodeScope(jjtn000, true);
1951 |  |
         }
1952 |  |
         }
1953 |  |
       }
1954 |  |
1955 |  |
       final public void Parameter() throws ParseException {
1956 |  |
         if (jj_2_9(3)) {
1957 |  |
           Expression();
1958 |  |
         } else {
1959 |  |
           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1960 |  |
           case INTEGER_LITERAL:
1961 |  |
           case FLOAT_LITERAL:
1962 |  |
           case 45:
1963 |  |
           case 46:
1964 |  |
           case 47:
1965 |  |
           case STRING_LITERAL:
1966 |  |
             Literal();
1967 |  |
             break;
1968 |  |
           case IDENTIFIER:
1969 |  |
             Reference();
1970 |  |
             break;
1971 |  |
           default:
1972 |  |
             jj_la1[33] = jj_gen;
1973 |  |
             jj_consume_token(-1);
1974 |  |
             throw new ParseException();
1975 |  |
           }
1976 |  |
         }
1977 |  |
       }
1978 |  |
1979 |  |
       final private boolean jj_2_1(int xla) {
1980 |  |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
1981 |  |
         boolean retval = !jj_3_1();
1982 |  |
         jj_save(0, xla);
1983 |  |
         return retval;
1984 |  |
       }
1985 |  |
1986 |  |
       final private boolean jj_2_2(int xla) {
1987 |  |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
1988 |  |
         boolean retval = !jj_3_2();
1989 |  |
         jj_save(1, xla);
1990 |  |
         return retval;
1991 |  |
       }
1992 |  |
1993 |  |
       final private boolean jj_2_3(int xla) {
1994 |  |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
1995 |  |
         boolean retval = !jj_3_3();
1996 |  |
         jj_save(2, xla);
1997 |  |
         return retval;
1998 |  |
       }
1999 |  |
2000 |  |
       final private boolean jj_2_4(int xla) {
2001 |  |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2002 |  |
         boolean retval = !jj_3_4();
2003 |  |
         jj_save(3, xla);
2004 |  |
         return retval;
2005 |  |
       }
2006 |  |
2007 |  |
       final private boolean jj_2_5(int xla) {
2008 |  |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2009 |  |
         boolean retval = !jj_3_5();
2010 |  |
         jj_save(4, xla);
2011 |  |
         return retval;
2012 |  |
       }
2013 |  |
2014 |  |
       final private boolean jj_2_6(int xla) {
2015 |  |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2016 |  |
         boolean retval = !jj_3_6();
2017 |  |
         jj_save(5, xla);
2018 |  |
         return retval;
2019 |  |
       }
2020 |  |
2021 |  |
       final private boolean jj_2_7(int xla) {
2022 |  |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2023 |  |
         boolean retval = !jj_3_7();
2024 |  |
         jj_save(6, xla);
2025 |  |
         return retval;
2026 |  |
       }
2027 |  |
2028 |  |
       final private boolean jj_2_8(int xla) {
2029 |  |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2030 |  |
         boolean retval = !jj_3_8();
2031 |  |
         jj_save(7, xla);
2032 |  |
         return retval;
2033 |  |
       }
2034 |  |
2035 |  |
       final private boolean jj_2_9(int xla) {
2036 |  |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
2037 |  |
         boolean retval = !jj_3_9();
2038 |  |
         jj_save(8, xla);
2039 |  |
         return retval;
2040 |  |
       }
2041 |  |
2042 |  |
       final private boolean jj_3R_71() {
2043 |  |
         if (jj_scan_token(17)) return true;
2044 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2045 |  |
         if (jj_3R_58()) return true;
2046 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2047 |  |
         return false;
2048 |  |
       }
2049 |  |
2050 |  |
       final private boolean jj_3R_59() {
2051 |  |
         Token xsp;
2052 |  |
         xsp = jj_scanpos;
2053 |  |
         if (jj_3R_70()) {
2054 |  |
         jj_scanpos = xsp;
2055 |  |
         if (jj_3R_71()) return true;
2056 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2057 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2058 |  |
         return false;
2059 |  |
       }
2060 |  |
2061 |  |
       final private boolean jj_3R_70() {
2062 |  |
         if (jj_scan_token(16)) return true;
2063 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2064 |  |
         if (jj_3R_58()) return true;
2065 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2066 |  |
         return false;
2067 |  |
       }
2068 |  |
2069 |  |
       final private boolean jj_3R_64() {
2070 |  |
         if (jj_scan_token(STRING_LITERAL)) return true;
2071 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2072 |  |
         return false;
2073 |  |
       }
2074 |  |
2075 |  |
       final private boolean jj_3R_47() {
2076 |  |
         if (jj_3R_58()) return true;
2077 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2078 |  |
         Token xsp;
2079 |  |
         while (true) {
2080 |  |
           xsp = jj_scanpos;
2081 |  |
           if (jj_3R_59()) { jj_scanpos = xsp; break; }
2082 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2083 |  |
         }
2084 |  |
         return false;
2085 |  |
       }
2086 |  |
2087 |  |
       final private boolean jj_3_1() {
2088 |  |
         if (jj_3R_15()) return true;
2089 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2090 |  |
         if (jj_scan_token(15)) return true;
2091 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2092 |  |
         return false;
2093 |  |
       }
2094 |  |
2095 |  |
       final private boolean jj_3R_46() {
2096 |  |
         if (jj_3R_15()) return true;
2097 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2098 |  |
         if (jj_scan_token(15)) return true;
2099 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2100 |  |
         if (jj_3R_17()) return true;
2101 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2102 |  |
         return false;
2103 |  |
       }
2104 |  |
2105 |  |
       final private boolean jj_3R_34() {
2106 |  |
         if (jj_3R_18()) return true;
2107 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2108 |  |
         return false;
2109 |  |
       }
2110 |  |
2111 |  |
       final private boolean jj_3R_62() {
2112 |  |
         if (jj_scan_token(FLOAT_LITERAL)) return true;
2113 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2114 |  |
         return false;
2115 |  |
       }
2116 |  |
2117 |  |
       final private boolean jj_3R_36() {
2118 |  |
         if (jj_3R_47()) return true;
2119 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2120 |  |
         return false;
2121 |  |
       }
2122 |  |
2123 |  |
       final private boolean jj_3R_35() {
2124 |  |
         if (jj_3R_46()) return true;
2125 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2126 |  |
         return false;
2127 |  |
       }
2128 |  |
2129 |  |
       final private boolean jj_3R_17() {
2130 |  |
         Token xsp;
2131 |  |
         xsp = jj_scanpos;
2132 |  |
         if (jj_3R_35()) {
2133 |  |
         jj_scanpos = xsp;
2134 |  |
         if (jj_3R_36()) return true;
2135 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2136 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2137 |  |
         return false;
2138 |  |
       }
2139 |  |
2140 |  |
       final private boolean jj_3R_56() {
2141 |  |
         if (jj_scan_token(12)) return true;
2142 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2143 |  |
         if (jj_3R_16()) return true;
2144 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2145 |  |
         if (jj_scan_token(13)) return true;
2146 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2147 |  |
         return false;
2148 |  |
       }
2149 |  |
2150 |  |
       final private boolean jj_3R_37() {
2151 |  |
         if (jj_scan_token(INTEGER_LITERAL)) return true;
2152 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2153 |  |
         return false;
2154 |  |
       }
2155 |  |
2156 |  |
       final private boolean jj_3R_18() {
2157 |  |
         if (jj_scan_token(IDENTIFIER)) return true;
2158 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2159 |  |
         return false;
2160 |  |
       }
2161 |  |
2162 |  |
       final private boolean jj_3R_73() {
2163 |  |
         if (jj_scan_token(47)) return true;
2164 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2165 |  |
         return false;
2166 |  |
       }
2167 |  |
2168 |  |
       final private boolean jj_3R_63() {
2169 |  |
         Token xsp;
2170 |  |
         xsp = jj_scanpos;
2171 |  |
         if (jj_3R_72()) {
2172 |  |
         jj_scanpos = xsp;
2173 |  |
         if (jj_3R_73()) return true;
2174 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2175 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2176 |  |
         return false;
2177 |  |
       }
2178 |  |
2179 |  |
       final private boolean jj_3R_72() {
2180 |  |
         if (jj_scan_token(46)) return true;
2181 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2182 |  |
         return false;
2183 |  |
       }
2184 |  |
2185 |  |
       final private boolean jj_3R_45() {
2186 |  |
         if (jj_scan_token(14)) return true;
2187 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2188 |  |
         if (jj_scan_token(12)) return true;
2189 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2190 |  |
         if (jj_3R_16()) return true;
2191 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2192 |  |
         if (jj_scan_token(13)) return true;
2193 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2194 |  |
         return false;
2195 |  |
       }
2196 |  |
2197 |  |
       final private boolean jj_3R_27() {
2198 |  |
         if (jj_3R_16()) return true;
2199 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2200 |  |
         return false;
2201 |  |
       }
2202 |  |
2203 |  |
       final private boolean jj_3R_65() {
2204 |  |
         if (jj_scan_token(45)) return true;
2205 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2206 |  |
         return false;
2207 |  |
       }
2208 |  |
2209 |  |
       final private boolean jj_3R_55() {
2210 |  |
         if (jj_3R_16()) return true;
2211 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2212 |  |
         return false;
2213 |  |
       }
2214 |  |
2215 |  |
       final private boolean jj_3R_41() {
2216 |  |
         if (jj_3R_37()) return true;
2217 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2218 |  |
         return false;
2219 |  |
       }
2220 |  |
2221 |  |
       final private boolean jj_3R_44() {
2222 |  |
         if (jj_scan_token(11)) return true;
2223 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2224 |  |
         Token xsp;
2225 |  |
         xsp = jj_scanpos;
2226 |  |
         if (jj_3R_55()) {
2227 |  |
         jj_scanpos = xsp;
2228 |  |
         if (jj_3R_56()) return true;
2229 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2230 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2231 |  |
         return false;
2232 |  |
       }
2233 |  |
2234 |  |
       final private boolean jj_3R_21() {
2235 |  |
         if (jj_3R_16()) return true;
2236 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2237 |  |
         return false;
2238 |  |
       }
2239 |  |
2240 |  |
       final private boolean jj_3R_54() {
2241 |  |
         if (jj_3R_65()) return true;
2242 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2243 |  |
         return false;
2244 |  |
       }
2245 |  |
2246 |  |
       final private boolean jj_3R_53() {
2247 |  |
         if (jj_3R_64()) return true;
2248 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2249 |  |
         return false;
2250 |  |
       }
2251 |  |
2252 |  |
       final private boolean jj_3R_67() {
2253 |  |
         if (jj_3R_16()) return true;
2254 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2255 |  |
         return false;
2256 |  |
       }
2257 |  |
2258 |  |
       final private boolean jj_3R_52() {
2259 |  |
         if (jj_3R_63()) return true;
2260 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2261 |  |
         return false;
2262 |  |
       }
2263 |  |
2264 |  |
       final private boolean jj_3R_61() {
2265 |  |
         if (jj_3R_16()) return true;
2266 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2267 |  |
         return false;
2268 |  |
       }
2269 |  |
2270 |  |
       final private boolean jj_3R_51() {
2271 |  |
         if (jj_3R_62()) return true;
2272 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2273 |  |
         return false;
2274 |  |
       }
2275 |  |
2276 |  |
       final private boolean jj_3R_43() {
2277 |  |
         Token xsp;
2278 |  |
         xsp = jj_scanpos;
2279 |  |
         if (jj_3R_50()) {
2280 |  |
         jj_scanpos = xsp;
2281 |  |
         if (jj_3R_51()) {
2282 |  |
         jj_scanpos = xsp;
2283 |  |
         if (jj_3R_52()) {
2284 |  |
         jj_scanpos = xsp;
2285 |  |
         if (jj_3R_53()) {
2286 |  |
         jj_scanpos = xsp;
2287 |  |
         if (jj_3R_54()) return true;
2288 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2289 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2290 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2291 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2292 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2293 |  |
         return false;
2294 |  |
       }
2295 |  |
2296 |  |
       final private boolean jj_3R_50() {
2297 |  |
         if (jj_3R_37()) return true;
2298 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2299 |  |
         return false;
2300 |  |
       }
2301 |  |
2302 |  |
       final private boolean jj_3R_26() {
2303 |  |
         if (jj_3R_37()) return true;
2304 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2305 |  |
         return false;
2306 |  |
       }
2307 |  |
2308 |  |
       final private boolean jj_3R_40() {
2309 |  |
         if (jj_3R_18()) return true;
2310 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2311 |  |
         return false;
2312 |  |
       }
2313 |  |
2314 |  |
       final private boolean jj_3R_20() {
2315 |  |
         if (jj_3R_37()) return true;
2316 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2317 |  |
         return false;
2318 |  |
       }
2319 |  |
2320 |  |
       final private boolean jj_3R_32() {
2321 |  |
         if (jj_3R_45()) return true;
2322 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2323 |  |
         return false;
2324 |  |
       }
2325 |  |
2326 |  |
       final private boolean jj_3R_60() {
2327 |  |
         if (jj_3R_43()) return true;
2328 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2329 |  |
         return false;
2330 |  |
       }
2331 |  |
2332 |  |
       final private boolean jj_3R_31() {
2333 |  |
         if (jj_3R_44()) return true;
2334 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2335 |  |
         return false;
2336 |  |
       }
2337 |  |
2338 |  |
       final private boolean jj_3R_30() {
2339 |  |
         if (jj_scan_token(12)) return true;
2340 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2341 |  |
         if (jj_3R_17()) return true;
2342 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2343 |  |
         if (jj_scan_token(13)) return true;
2344 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2345 |  |
         return false;
2346 |  |
       }
2347 |  |
2348 |  |
       final private boolean jj_3R_66() {
2349 |  |
         if (jj_3R_37()) return true;
2350 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2351 |  |
         return false;
2352 |  |
       }
2353 |  |
2354 |  |
       final private boolean jj_3R_29() {
2355 |  |
         if (jj_3R_16()) return true;
2356 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2357 |  |
         return false;
2358 |  |
       }
2359 |  |
2360 |  |
       final private boolean jj_3R_28() {
2361 |  |
         if (jj_3R_43()) return true;
2362 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2363 |  |
         return false;
2364 |  |
       }
2365 |  |
2366 |  |
       final private boolean jj_3R_15() {
2367 |  |
         Token xsp;
2368 |  |
         xsp = jj_scanpos;
2369 |  |
         if (jj_3R_28()) {
2370 |  |
         jj_scanpos = xsp;
2371 |  |
         if (jj_3R_29()) {
2372 |  |
         jj_scanpos = xsp;
2373 |  |
         if (jj_3R_30()) {
2374 |  |
         jj_scanpos = xsp;
2375 |  |
         if (jj_3R_31()) {
2376 |  |
         jj_scanpos = xsp;
2377 |  |
         if (jj_3R_32()) return true;
2378 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2379 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2380 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2381 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2382 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2383 |  |
         return false;
2384 |  |
       }
2385 |  |
2386 |  |
       final private boolean jj_3R_25() {
2387 |  |
         if (jj_3R_17()) return true;
2388 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2389 |  |
         return false;
2390 |  |
       }
2391 |  |
2392 |  |
       final private boolean jj_3R_39() {
2393 |  |
         if (jj_3R_48()) return true;
2394 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2395 |  |
         return false;
2396 |  |
       }
2397 |  |
2398 |  |
       final private boolean jj_3R_109() {
2399 |  |
         if (jj_3R_15()) return true;
2400 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2401 |  |
         return false;
2402 |  |
       }
2403 |  |
2404 |  |
       final private boolean jj_3R_19() {
2405 |  |
         if (jj_3R_17()) return true;
2406 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2407 |  |
         return false;
2408 |  |
       }
2409 |  |
2410 |  |
       final private boolean jj_3R_108() {
2411 |  |
         if (jj_scan_token(44)) return true;
2412 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2413 |  |
         if (jj_3R_101()) return true;
2414 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2415 |  |
         return false;
2416 |  |
       }
2417 |  |
2418 |  |
       final private boolean jj_3R_107() {
2419 |  |
         if (jj_scan_token(43)) return true;
2420 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2421 |  |
         if (jj_3R_101()) return true;
2422 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2423 |  |
         return false;
2424 |  |
       }
2425 |  |
2426 |  |
       final private boolean jj_3R_106() {
2427 |  |
         if (jj_scan_token(42)) return true;
2428 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2429 |  |
         if (jj_3R_101()) return true;
2430 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2431 |  |
         return false;
2432 |  |
       }
2433 |  |
2434 |  |
       final private boolean jj_3R_105() {
2435 |  |
         if (jj_scan_token(36)) return true;
2436 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2437 |  |
         if (jj_3R_101()) return true;
2438 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2439 |  |
         return false;
2440 |  |
       }
2441 |  |
2442 |  |
       final private boolean jj_3R_101() {
2443 |  |
         Token xsp;
2444 |  |
         xsp = jj_scanpos;
2445 |  |
         if (jj_3R_105()) {
2446 |  |
         jj_scanpos = xsp;
2447 |  |
         if (jj_3R_106()) {
2448 |  |
         jj_scanpos = xsp;
2449 |  |
         if (jj_3R_107()) {
2450 |  |
         jj_scanpos = xsp;
2451 |  |
         if (jj_3R_108()) {
2452 |  |
         jj_scanpos = xsp;
2453 |  |
         if (jj_3R_109()) return true;
2454 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2455 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2456 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2457 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2458 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2459 |  |
         return false;
2460 |  |
       }
2461 |  |
2462 |  |
       final private boolean jj_3R_78() {
2463 |  |
         if (jj_scan_token(54)) return true;
2464 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2465 |  |
         if (jj_3R_49()) return true;
2466 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2467 |  |
         return false;
2468 |  |
       }
2469 |  |
2470 |  |
       final private boolean jj_3R_114() {
2471 |  |
         if (jj_scan_token(41)) return true;
2472 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2473 |  |
         if (jj_3R_101()) return true;
2474 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2475 |  |
         return false;
2476 |  |
       }
2477 |  |
2478 |  |
       final private boolean jj_3_8() {
2479 |  |
         if (jj_3R_18()) return true;
2480 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2481 |  |
         if (jj_scan_token(55)) return true;
2482 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2483 |  |
         Token xsp;
2484 |  |
         xsp = jj_scanpos;
2485 |  |
         if (jj_3R_25()) {
2486 |  |
         jj_scanpos = xsp;
2487 |  |
         if (jj_3R_26()) {
2488 |  |
         jj_scanpos = xsp;
2489 |  |
         if (jj_3R_27()) return true;
2490 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2491 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2492 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2493 |  |
         if (jj_scan_token(56)) return true;
2494 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2495 |  |
         return false;
2496 |  |
       }
2497 |  |
2498 |  |
       final private boolean jj_3R_113() {
2499 |  |
         if (jj_scan_token(40)) return true;
2500 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2501 |  |
         if (jj_3R_101()) return true;
2502 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2503 |  |
         return false;
2504 |  |
       }
2505 |  |
2506 |  |
       final private boolean jj_3_9() {
2507 |  |
         if (jj_3R_17()) return true;
2508 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2509 |  |
         return false;
2510 |  |
       }
2511 |  |
2512 |  |
       final private boolean jj_3R_49() {
2513 |  |
         Token xsp;
2514 |  |
         xsp = jj_scanpos;
2515 |  |
         if (jj_3_9()) {
2516 |  |
         jj_scanpos = xsp;
2517 |  |
         if (jj_3R_60()) {
2518 |  |
         jj_scanpos = xsp;
2519 |  |
         if (jj_3R_61()) return true;
2520 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2521 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2522 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2523 |  |
         return false;
2524 |  |
       }
2525 |  |
2526 |  |
       final private boolean jj_3R_112() {
2527 |  |
         if (jj_scan_token(39)) return true;
2528 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2529 |  |
         if (jj_3R_101()) return true;
2530 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2531 |  |
         return false;
2532 |  |
       }
2533 |  |
2534 |  |
       final private boolean jj_3_4() {
2535 |  |
         if (jj_3R_17()) return true;
2536 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2537 |  |
         return false;
2538 |  |
       }
2539 |  |
2540 |  |
       final private boolean jj_3R_111() {
2541 |  |
         if (jj_scan_token(38)) return true;
2542 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2543 |  |
         if (jj_3R_101()) return true;
2544 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2545 |  |
         return false;
2546 |  |
       }
2547 |  |
2548 |  |
       final private boolean jj_3_5() {
2549 |  |
         if (jj_3R_18()) return true;
2550 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2551 |  |
         if (jj_scan_token(55)) return true;
2552 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2553 |  |
         Token xsp;
2554 |  |
         xsp = jj_scanpos;
2555 |  |
         if (jj_3R_19()) {
2556 |  |
         jj_scanpos = xsp;
2557 |  |
         if (jj_3R_20()) {
2558 |  |
         jj_scanpos = xsp;
2559 |  |
         if (jj_3R_21()) return true;
2560 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2561 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2562 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2563 |  |
         if (jj_scan_token(56)) return true;
2564 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2565 |  |
         return false;
2566 |  |
       }
2567 |  |
2568 |  |
       final private boolean jj_3_7() {
2569 |  |
         if (jj_3R_24()) return true;
2570 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2571 |  |
         return false;
2572 |  |
       }
2573 |  |
2574 |  |
       final private boolean jj_3R_110() {
2575 |  |
         if (jj_scan_token(37)) return true;
2576 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2577 |  |
         if (jj_3R_101()) return true;
2578 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2579 |  |
         return false;
2580 |  |
       }
2581 |  |
2582 |  |
       final private boolean jj_3R_102() {
2583 |  |
         Token xsp;
2584 |  |
         xsp = jj_scanpos;
2585 |  |
         if (jj_3R_110()) {
2586 |  |
         jj_scanpos = xsp;
2587 |  |
         if (jj_3R_111()) {
2588 |  |
         jj_scanpos = xsp;
2589 |  |
         if (jj_3R_112()) {
2590 |  |
         jj_scanpos = xsp;
2591 |  |
         if (jj_3R_113()) {
2592 |  |
         jj_scanpos = xsp;
2593 |  |
         if (jj_3R_114()) return true;
2594 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2595 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2596 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2597 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2598 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2599 |  |
         return false;
2600 |  |
       }
2601 |  |
2602 |  |
       final private boolean jj_3R_23() {
2603 |  |
         Token xsp;
2604 |  |
         xsp = jj_scanpos;
2605 |  |
         if (jj_3_7()) {
2606 |  |
         jj_scanpos = xsp;
2607 |  |
         if (jj_3R_39()) {
2608 |  |
         jj_scanpos = xsp;
2609 |  |
         if (jj_3R_40()) {
2610 |  |
         jj_scanpos = xsp;
2611 |  |
         if (jj_3R_41()) return true;
2612 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2613 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2614 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2615 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2616 |  |
         return false;
2617 |  |
       }
2618 |  |
2619 |  |
       final private boolean jj_3R_22() {
2620 |  |
         if (jj_3R_38()) return true;
2621 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2622 |  |
         return false;
2623 |  |
       }
2624 |  |
2625 |  |
       final private boolean jj_3R_57() {
2626 |  |
         if (jj_scan_token(55)) return true;
2627 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2628 |  |
         Token xsp;
2629 |  |
         xsp = jj_scanpos;
2630 |  |
         if (jj_3_4()) {
2631 |  |
         jj_scanpos = xsp;
2632 |  |
         if (jj_3R_66()) {
2633 |  |
         jj_scanpos = xsp;
2634 |  |
         if (jj_3R_67()) return true;
2635 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2636 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2637 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2638 |  |
         if (jj_scan_token(56)) return true;
2639 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2640 |  |
         return false;
2641 |  |
       }
2642 |  |
2643 |  |
       final private boolean jj_3R_91() {
2644 |  |
         if (jj_3R_101()) return true;
2645 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2646 |  |
         Token xsp;
2647 |  |
         while (true) {
2648 |  |
           xsp = jj_scanpos;
2649 |  |
           if (jj_3R_102()) { jj_scanpos = xsp; break; }
2650 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2651 |  |
         }
2652 |  |
         return false;
2653 |  |
       }
2654 |  |
2655 |  |
       final private boolean jj_3R_42() {
2656 |  |
         if (jj_3R_49()) return true;
2657 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2658 |  |
         Token xsp;
2659 |  |
         while (true) {
2660 |  |
           xsp = jj_scanpos;
2661 |  |
           if (jj_3R_78()) { jj_scanpos = xsp; break; }
2662 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2663 |  |
         }
2664 |  |
         return false;
2665 |  |
       }
2666 |  |
2667 |  |
       final private boolean jj_3_6() {
2668 |  |
         if (jj_scan_token(57)) return true;
2669 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2670 |  |
         Token xsp;
2671 |  |
         xsp = jj_scanpos;
2672 |  |
         if (jj_3R_22()) {
2673 |  |
         jj_scanpos = xsp;
2674 |  |
         if (jj_3R_23()) return true;
2675 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2676 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2677 |  |
         return false;
2678 |  |
       }
2679 |  |
2680 |  |
       final private boolean jj_3R_33() {
2681 |  |
         if (jj_3R_38()) return true;
2682 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2683 |  |
         return false;
2684 |  |
       }
2685 |  |
2686 |  |
       final private boolean jj_3R_48() {
2687 |  |
         if (jj_scan_token(14)) return true;
2688 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2689 |  |
         if (jj_scan_token(12)) return true;
2690 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2691 |  |
         if (jj_scan_token(13)) return true;
2692 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2693 |  |
         return false;
2694 |  |
       }
2695 |  |
2696 |  |
       final private boolean jj_3R_104() {
2697 |  |
         if (jj_scan_token(36)) return true;
2698 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2699 |  |
         if (jj_3R_91()) return true;
2700 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2701 |  |
         return false;
2702 |  |
       }
2703 |  |
2704 |  |
       final private boolean jj_3R_16() {
2705 |  |
         Token xsp;
2706 |  |
         xsp = jj_scanpos;
2707 |  |
         if (jj_3R_33()) {
2708 |  |
         jj_scanpos = xsp;
2709 |  |
         if (jj_3R_34()) return true;
2710 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2711 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2712 |  |
         while (true) {
2713 |  |
           xsp = jj_scanpos;
2714 |  |
           if (jj_3_6()) { jj_scanpos = xsp; break; }
2715 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2716 |  |
         }
2717 |  |
         return false;
2718 |  |
       }
2719 |  |
2720 |  |
       final private boolean jj_3R_103() {
2721 |  |
         if (jj_scan_token(35)) return true;
2722 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2723 |  |
         if (jj_3R_91()) return true;
2724 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2725 |  |
         return false;
2726 |  |
       }
2727 |  |
2728 |  |
       final private boolean jj_3R_92() {
2729 |  |
         Token xsp;
2730 |  |
         xsp = jj_scanpos;
2731 |  |
         if (jj_3R_103()) {
2732 |  |
         jj_scanpos = xsp;
2733 |  |
         if (jj_3R_104()) return true;
2734 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2735 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2736 |  |
         return false;
2737 |  |
       }
2738 |  |
2739 |  |
       final private boolean jj_3R_85() {
2740 |  |
         if (jj_3R_91()) return true;
2741 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2742 |  |
         Token xsp;
2743 |  |
         while (true) {
2744 |  |
           xsp = jj_scanpos;
2745 |  |
           if (jj_3R_92()) { jj_scanpos = xsp; break; }
2746 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2747 |  |
         }
2748 |  |
         return false;
2749 |  |
       }
2750 |  |
2751 |  |
       final private boolean jj_3R_38() {
2752 |  |
         if (jj_3R_18()) return true;
2753 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2754 |  |
         Token xsp;
2755 |  |
         if (jj_3R_57()) return true;
2756 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2757 |  |
         while (true) {
2758 |  |
           xsp = jj_scanpos;
2759 |  |
           if (jj_3R_57()) { jj_scanpos = xsp; break; }
2760 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2761 |  |
         }
2762 |  |
         return false;
2763 |  |
       }
2764 |  |
2765 |  |
       final private boolean jj_3R_100() {
2766 |  |
         if (jj_scan_token(34)) return true;
2767 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2768 |  |
         if (jj_3R_85()) return true;
2769 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2770 |  |
         return false;
2771 |  |
       }
2772 |  |
2773 |  |
       final private boolean jj_3R_99() {
2774 |  |
         if (jj_scan_token(33)) return true;
2775 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2776 |  |
         if (jj_3R_85()) return true;
2777 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2778 |  |
         return false;
2779 |  |
       }
2780 |  |
2781 |  |
       final private boolean jj_3R_24() {
2782 |  |
         if (jj_3R_18()) return true;
2783 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2784 |  |
         if (jj_scan_token(12)) return true;
2785 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2786 |  |
         Token xsp;
2787 |  |
         xsp = jj_scanpos;
2788 |  |
         if (jj_3R_42()) jj_scanpos = xsp;
2789 |  |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2790 |  |
         if (jj_scan_token(13)) return true;
2791 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2792 |  |
         return false;
2793 |  |
       }
2794 |  |
2795 |  |
       final private boolean jj_3R_98() {
2796 |  |
         if (jj_scan_token(32)) return true;
2797 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2798 |  |
         if (jj_3R_85()) return true;
2799 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2800 |  |
         return false;
2801 |  |
       }
2802 |  |
2803 |  |
       final private boolean jj_3R_97() {
2804 |  |
         if (jj_scan_token(31)) return true;
2805 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2806 |  |
         if (jj_3R_85()) return true;
2807 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2808 |  |
         return false;
2809 |  |
       }
2810 |  |
2811 |  |
       final private boolean jj_3R_96() {
2812 |  |
         if (jj_scan_token(30)) return true;
2813 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2814 |  |
         if (jj_3R_85()) return true;
2815 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2816 |  |
         return false;
2817 |  |
       }
2818 |  |
2819 |  |
       final private boolean jj_3R_95() {
2820 |  |
         if (jj_scan_token(29)) return true;
2821 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2822 |  |
         if (jj_3R_85()) return true;
2823 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2824 |  |
         return false;
2825 |  |
       }
2826 |  |
2827 |  |
       final private boolean jj_3R_94() {
2828 |  |
         if (jj_scan_token(28)) return true;
2829 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2830 |  |
         if (jj_3R_85()) return true;
2831 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2832 |  |
         return false;
2833 |  |
       }
2834 |  |
2835 |  |
       final private boolean jj_3R_93() {
2836 |  |
         if (jj_scan_token(27)) return true;
2837 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2838 |  |
         if (jj_3R_85()) return true;
2839 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2840 |  |
         return false;
2841 |  |
       }
2842 |  |
2843 |  |
       final private boolean jj_3R_86() {
2844 |  |
         Token xsp;
2845 |  |
         xsp = jj_scanpos;
2846 |  |
         if (jj_3R_93()) {
2847 |  |
         jj_scanpos = xsp;
2848 |  |
         if (jj_3R_94()) {
2849 |  |
         jj_scanpos = xsp;
2850 |  |
         if (jj_3R_95()) {
2851 |  |
         jj_scanpos = xsp;
2852 |  |
         if (jj_3R_96()) {
2853 |  |
         jj_scanpos = xsp;
2854 |  |
         if (jj_3R_97()) {
2855 |  |
         jj_scanpos = xsp;
2856 |  |
         if (jj_3R_98()) {
2857 |  |
         jj_scanpos = xsp;
2858 |  |
         if (jj_3R_99()) {
2859 |  |
         jj_scanpos = xsp;
2860 |  |
         if (jj_3R_100()) return true;
2861 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2862 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2863 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2864 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2865 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2866 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2867 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2868 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2869 |  |
         return false;
2870 |  |
       }
2871 |  |
2872 |  |
       final private boolean jj_3R_83() {
2873 |  |
         if (jj_3R_85()) return true;
2874 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2875 |  |
         Token xsp;
2876 |  |
         while (true) {
2877 |  |
           xsp = jj_scanpos;
2878 |  |
           if (jj_3R_86()) { jj_scanpos = xsp; break; }
2879 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2880 |  |
         }
2881 |  |
         return false;
2882 |  |
       }
2883 |  |
2884 |  |
       final private boolean jj_3R_90() {
2885 |  |
         if (jj_scan_token(26)) return true;
2886 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2887 |  |
         if (jj_3R_83()) return true;
2888 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2889 |  |
         return false;
2890 |  |
       }
2891 |  |
2892 |  |
       final private boolean jj_3R_89() {
2893 |  |
         if (jj_scan_token(25)) return true;
2894 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2895 |  |
         if (jj_3R_83()) return true;
2896 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2897 |  |
         return false;
2898 |  |
       }
2899 |  |
2900 |  |
       final private boolean jj_3R_88() {
2901 |  |
         if (jj_scan_token(24)) return true;
2902 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2903 |  |
         if (jj_3R_83()) return true;
2904 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2905 |  |
         return false;
2906 |  |
       }
2907 |  |
2908 |  |
       final private boolean jj_3R_87() {
2909 |  |
         if (jj_scan_token(23)) return true;
2910 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2911 |  |
         if (jj_3R_83()) return true;
2912 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2913 |  |
         return false;
2914 |  |
       }
2915 |  |
2916 |  |
       final private boolean jj_3R_84() {
2917 |  |
         Token xsp;
2918 |  |
         xsp = jj_scanpos;
2919 |  |
         if (jj_3R_87()) {
2920 |  |
         jj_scanpos = xsp;
2921 |  |
         if (jj_3R_88()) {
2922 |  |
         jj_scanpos = xsp;
2923 |  |
         if (jj_3R_89()) {
2924 |  |
         jj_scanpos = xsp;
2925 |  |
         if (jj_3R_90()) return true;
2926 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2927 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2928 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2929 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2930 |  |
         return false;
2931 |  |
       }
2932 |  |
2933 |  |
       final private boolean jj_3R_81() {
2934 |  |
         if (jj_3R_83()) return true;
2935 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2936 |  |
         Token xsp;
2937 |  |
         while (true) {
2938 |  |
           xsp = jj_scanpos;
2939 |  |
           if (jj_3R_84()) { jj_scanpos = xsp; break; }
2940 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2941 |  |
         }
2942 |  |
         return false;
2943 |  |
       }
2944 |  |
2945 |  |
       final private boolean jj_3R_82() {
2946 |  |
         if (jj_scan_token(22)) return true;
2947 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2948 |  |
         if (jj_3R_81()) return true;
2949 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2950 |  |
         return false;
2951 |  |
       }
2952 |  |
2953 |  |
       final private boolean jj_3R_79() {
2954 |  |
         if (jj_3R_81()) return true;
2955 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2956 |  |
         Token xsp;
2957 |  |
         while (true) {
2958 |  |
           xsp = jj_scanpos;
2959 |  |
           if (jj_3R_82()) { jj_scanpos = xsp; break; }
2960 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2961 |  |
         }
2962 |  |
         return false;
2963 |  |
       }
2964 |  |
2965 |  |
       final private boolean jj_3_3() {
2966 |  |
         if (jj_3R_15()) return true;
2967 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2968 |  |
         if (jj_scan_token(15)) return true;
2969 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2970 |  |
         return false;
2971 |  |
       }
2972 |  |
2973 |  |
       final private boolean jj_3_2() {
2974 |  |
         if (jj_3R_16()) return true;
2975 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2976 |  |
         if (jj_scan_token(48)) return true;
2977 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2978 |  |
         return false;
2979 |  |
       }
2980 |  |
2981 |  |
       final private boolean jj_3R_80() {
2982 |  |
         if (jj_scan_token(21)) return true;
2983 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2984 |  |
         if (jj_3R_79()) return true;
2985 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2986 |  |
         return false;
2987 |  |
       }
2988 |  |
2989 |  |
       final private boolean jj_3R_74() {
2990 |  |
         if (jj_3R_79()) return true;
2991 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2992 |  |
         Token xsp;
2993 |  |
         while (true) {
2994 |  |
           xsp = jj_scanpos;
2995 |  |
           if (jj_3R_80()) { jj_scanpos = xsp; break; }
2996 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
2997 |  |
         }
2998 |  |
         return false;
2999 |  |
       }
3000 |  |
3001 |  |
       final private boolean jj_3R_75() {
3002 |  |
         if (jj_scan_token(20)) return true;
3003 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3004 |  |
         if (jj_3R_74()) return true;
3005 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3006 |  |
         return false;
3007 |  |
       }
3008 |  |
3009 |  |
       final private boolean jj_3R_68() {
3010 |  |
         if (jj_3R_74()) return true;
3011 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3012 |  |
         Token xsp;
3013 |  |
         while (true) {
3014 |  |
           xsp = jj_scanpos;
3015 |  |
           if (jj_3R_75()) { jj_scanpos = xsp; break; }
3016 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3017 |  |
         }
3018 |  |
         return false;
3019 |  |
       }
3020 |  |
3021 |  |
       final private boolean jj_3R_77() {
3022 |  |
         if (jj_scan_token(19)) return true;
3023 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3024 |  |
         if (jj_3R_68()) return true;
3025 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3026 |  |
         return false;
3027 |  |
       }
3028 |  |
3029 |  |
       final private boolean jj_3R_69() {
3030 |  |
         Token xsp;
3031 |  |
         xsp = jj_scanpos;
3032 |  |
         if (jj_3R_76()) {
3033 |  |
         jj_scanpos = xsp;
3034 |  |
         if (jj_3R_77()) return true;
3035 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3036 |  |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3037 |  |
         return false;
3038 |  |
       }
3039 |  |
3040 |  |
       final private boolean jj_3R_76() {
3041 |  |
         if (jj_scan_token(18)) return true;
3042 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3043 |  |
         if (jj_3R_68()) return true;
3044 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3045 |  |
         return false;
3046 |  |
       }
3047 |  |
3048 |  |
       final private boolean jj_3R_58() {
3049 |  |
         if (jj_3R_68()) return true;
3050 |  |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3051 |  |
         Token xsp;
3052 |  |
         while (true) {
3053 |  |
           xsp = jj_scanpos;
3054 |  |
           if (jj_3R_69()) { jj_scanpos = xsp; break; }
3055 |  |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3056 |  |
         }
3057 |  |
         return false;
3058 |  |
       }
3059 |  |
3060 |  |
       public ParserTokenManager token_source;
3061 |  |
       SimpleCharStream jj_input_stream;
3062 |  |
       public Token token, jj_nt;
3063 |  |
       private int jj_ntk;
3064 |  |
       private Token jj_scanpos, jj_lastpos;
3065 |  |
       private int jj_la;
3066 |  |
       public boolean lookingAhead = false;
3067 |  |
       private boolean jj_semLA;
3068 |  |
       private int jj_gen;
3069 |  |
       final private int[] jj_la1 = new class="keyword">int[34];
3070 |  |
       final private int[] jj_la1_0 = {0x5b80,0x5b80,0x1000,0x5980,0x30000,0x30000,0xc0000,0xc0000,0x100000,0x200000,0x400000,0x7800000,0x7800000,0xf8000000,0xf8000000,0x0,0x0,0x0,0x0,0x5980,0x5980,0x180,0x0,0x200,0x5980,0x0,0x0,0x5980,0x80,0x0,0x0,0x4080,0x4080,0x180,};
3071 |  |
       final private int[] jj_la1_1 = {0x241bfc10,0x241bfc10,0x4000000,0x2400fc10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x7,0x18,0x18,0x3e0,0x3e0,0x2400fc10,0x2400e000,0x2000e000,0xc000,0x10000,0x241afc10,0x40000,0x400000,0x2400fc10,0x4000000,0x800000,0x4000000,0x4000000,0x4000000,0x2400e000,};
3072 |  |
       final private JJCalls[] jj_2_rtns = new JJCalls[9];
3073 |  |
       private boolean jj_rescan = false;
3074 |  |
       private int jj_gc = 0;
3075 |  |
3076 |  |
       public Parser(java.io.InputStream stream) {
3077 |  |
         jj_input_stream = new SimpleCharStream(stream, 1, 1);
3078 |  |
         token_source = new ParserTokenManager(jj_input_stream);
3079 |  |
         token = new Token();
3080 |  |
         jj_ntk = -1;
3081 |  |
         jj_gen = 0;
3082 |  |
         for (int i = 0; i < 34; i++) jj_la1[i] = -1;
3083 |  |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3084 |  |
       }
3085 |  |
3086 |  |
       public void ReInit(java.io.InputStream stream) {
3087 |  |
         jj_input_stream.ReInit(stream, 1, 1);
3088 |  |
         token_source.ReInit(jj_input_stream);
3089 |  |
         token = new Token();
3090 |  |
         jj_ntk = -1;
3091 |  |
         jjtree.reset();
3092 |  |
         jj_gen = 0;
3093 |  |
         for (int i = 0; i < 34; i++) jj_la1[i] = -1;
3094 |  |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3095 |  |
       }
3096 |  |
3097 |  |
       public Parser(java.io.Reader stream) {
3098 |  |
         jj_input_stream = new SimpleCharStream(stream, 1, 1);
3099 |  |
         token_source = new ParserTokenManager(jj_input_stream);
3100 |  |
         token = new Token();
3101 |  |
         jj_ntk = -1;
3102 |  |
         jj_gen = 0;
3103 |  |
         for (int i = 0; i < 34; i++) jj_la1[i] = -1;
3104 |  |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3105 |  |
       }
3106 |  |
3107 |  |
       public void ReInit(java.io.Reader stream) {
3108 |  |
         jj_input_stream.ReInit(stream, 1, 1);
3109 |  |
         token_source.ReInit(jj_input_stream);
3110 |  |
         token = new Token();
3111 |  |
         jj_ntk = -1;
3112 |  |
         jjtree.reset();
3113 |  |
         jj_gen = 0;
3114 |  |
         for (int i = 0; i < 34; i++) jj_la1[i] = -1;
3115 |  |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3116 |  |
       }
3117 |  |
3118 |  |
       public Parser(ParserTokenManager tm) {
3119 |  |
         token_source = tm;
3120 |  |
         token = new Token();
3121 |  |
         jj_ntk = -1;
3122 |  |
         jj_gen = 0;
3123 |  |
         for (int i = 0; i < 34; i++) jj_la1[i] = -1;
3124 |  |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3125 |  |
       }
3126 |  |
3127 |  |
       public void ReInit(ParserTokenManager tm) {
3128 |  |
         token_source = tm;
3129 |  |
         token = new Token();
3130 |  |
         jj_ntk = -1;
3131 |  |
         jjtree.reset();
3132 |  |
         jj_gen = 0;
3133 |  |
         for (int i = 0; i < 34; i++) jj_la1[i] = -1;
3134 |  |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3135 |  |
       }
3136 |  |
3137 |  |
       final private Token jj_consume_token(int kind) throws ParseException {
3138 |  |
         Token oldToken;
3139 |  |
         if ((oldToken = token).next != null) token = token.next;
3140 |  |
         else token = token.next = token_source.getNextToken();
3141 |  |
         jj_ntk = -1;
3142 |  |
         if (token.kind == kind) {
3143 |  |
           jj_gen++;
3144 |  |
           if (++jj_gc > 100) {
3145 |  |
             jj_gc = 0;
3146 |  |
             for (int i = 0; i < jj_2_rtns.length; i++) {
3147 |  |
               JJCalls c = jj_2_rtns[i];
3148 |  |
               while (c != null) {
3149 |  |
                 if (c.gen < jj_gen) c.first = null;
3150 |  |
                 c = c.next;
3151 |  |
               }
3152 |  |
             }
3153 |  |
           }
3154 |  |
           return token;
3155 |  |
         }
3156 |  |
         token = oldToken;
3157 |  |
         jj_kind = kind;
3158 |  |
         throw generateParseException();
3159 |  |
       }
3160 |  |
3161 |  |
       final private boolean jj_scan_token(int kind) {
3162 |  |
         if (jj_scanpos == jj_lastpos) {
3163 |  |
           jj_la--;
3164 |  |
           if (jj_scanpos.next == null) {
3165 |  |
             jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3166 |  |
           } else {
3167 |  |
             jj_lastpos = jj_scanpos = jj_scanpos.next;
3168 |  |
           }
3169 |  |
         } else {
3170 |  |
           jj_scanpos = jj_scanpos.next;
3171 |  |
         }
3172 |  |
         if (jj_rescan) {
3173 |  |
           int i = 0; Token tok = token;
3174 |  |
           while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3175 |  |
           if (tok != null) jj_add_error_token(kind, i);
3176 |  |
         }
3177 |  |
         return (jj_scanpos.kind != kind);
3178 |  |
       }
3179 |  |
3180 |  |
       final public Token getNextToken() {
3181 |  |
         if (token.next != null) token = token.next;
3182 |  |
         else token = token.next = token_source.getNextToken();
3183 |  |
         jj_ntk = -1;
3184 |  |
         jj_gen++;
3185 |  |
         return token;
3186 |  |
       }
3187 |  |
3188 |  |
       final public Token getToken(int index) {
3189 |  |
         Token t = lookingAhead ? jj_scanpos : token;
3190 |  |
         for (int i = 0; i < index; i++) {
3191 |  |
           if (t.next != null) t = t.next;
3192 |  |
           else t = t.next = token_source.getNextToken();
3193 |  |
         }
3194 |  |
         return t;
3195 |  |
       }
3196 |  |
3197 |  |
       final private int jj_ntk() {
3198 |  |
         if ((jj_nt=token.next) == null)
3199 |  |
           return (jj_ntk = (token.next=token_source.getNextToken()).kind);
3200 |  |
         else
3201 |  |
           return (jj_ntk = jj_nt.kind);
3202 |  |
       }
3203 |  |
3204 |  |
       private java.util.Vector jj_expentries = new java.util.Vector();
3205 |  |
       private int[] jj_expentry;
3206 |  |
       private int jj_kind = -1;
3207 |  |
       private int[] jj_lasttokens = new class="keyword">int[100];
3208 |  |
       private int jj_endpos;
3209 |  |
3210 |  |
       private void jj_add_error_token(int kind, class="keyword">int pos) {
3211 |  |
         if (pos >= 100) return;
3212 |  |
         if (pos == jj_endpos + 1) {
3213 |  |
           jj_lasttokens[jj_endpos++] = kind;
3214 |  |
         } else if (jj_endpos != 0) {
3215 |  |
           jj_expentry = new int[jj_endpos];
3216 |  |
           for (int i = 0; i < jj_endpos; i++) {
3217 |  |
             jj_expentry[i] = jj_lasttokens[i];
3218 |  |
           }
3219 |  |
           boolean exists = false;
3220 |  |
           for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
3221 |  |
             int[] oldentry = (class="keyword">int[])(enum.nextElement());
3222 |  |
             if (oldentry.length == jj_expentry.length) {
3223 |  |
               exists = true;
3224 |  |
               for (int i = 0; i < jj_expentry.length; i++) {
3225 |  |
                 if (oldentry[i] != jj_expentry[i]) {
3226 |  |
                   exists = false;
3227 |  |
                   break;
3228 |  |
                 }
3229 |  |
               }
3230 |  |
               if (exists) break;
3231 |  |
             }
3232 |  |
           }
3233 |  |
           if (!exists) jj_expentries.addElement(jj_expentry);
3234 |  |
           if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3235 |  |
         }
3236 |  |
       }
3237 |  |
3238 |  |
       final public ParseException generateParseException() {
3239 |  |
         jj_expentries.removeAllElements();
3240 |  |
         boolean[] la1tokens = new class="keyword">boolean[62];
3241 |  |
         for (int i = 0; i < 62; i++) {
3242 |  |
           la1tokens[i] = false;
3243 |  |
         }
3244 |  |
         if (jj_kind >= 0) {
3245 |  |
           la1tokens[jj_kind] = true;
3246 |  |
           jj_kind = -1;
3247 |  |
         }
3248 |  |
         for (int i = 0; i < 34; i++) {
3249 |  |
           if (jj_la1[i] == jj_gen) {
3250 |  |
             for (int j = 0; j < 32; j++) {
3251 |  |
               if ((jj_la1_0[i] & (1<<j)) != 0) {
3252 |  |
                 la1tokens[j] = true;
3253 |  |
               }
3254 |  |
               if ((jj_la1_1[i] & (1<<j)) != 0) {
3255 |  |
                 la1tokens[32+j] = true;
3256 |  |
               }
3257 |  |
             }
3258 |  |
           }
3259 |  |
         }
3260 |  |
         for (int i = 0; i < 62; i++) {
3261 |  |
           if (la1tokens[i]) {
3262 |  |
             jj_expentry = new int[1];
3263 |  |
             jj_expentry[0] = i;
3264 |  |
             jj_expentries.addElement(jj_expentry);
3265 |  |
           }
3266 |  |
         }
3267 |  |
         jj_endpos = 0;
3268 |  |
         jj_rescan_token();
3269 |  |
         jj_add_error_token(0, 0);
3270 |  |
         int[][] exptokseq = new class="keyword">int[jj_expentries.size()][];
3271 |  |
         for (int i = 0; i < jj_expentries.size(); i++) {
3272 |  |
           exptokseq[i] = (int[])jj_expentries.elementAt(i);
3273 |  |
         }
3274 |  |
         return new ParseException(token, exptokseq, tokenImage);
3275 |  |
       }
3276 |  |
3277 |  |
       final public void enable_tracing() {
3278 |  |
       }
3279 |  |
3280 |  |
       final public void disable_tracing() {
3281 |  |
       }
3282 |  |
3283 |  |
       final private void jj_rescan_token() {
3284 |  |
         jj_rescan = true;
3285 |  |
         for (int i = 0; i < 9; i++) {
3286 |  |
           JJCalls p = jj_2_rtns[i];
3287 |  |
           do {
3288 |  |
             if (p.gen > jj_gen) {
3289 |  |
               jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3290 |  |
               switch (i) {
3291 |  |
                 case 0: jj_3_1(); break;
3292 |  |
                 case 1: jj_3_2(); break;
3293 |  |
                 case 2: jj_3_3(); break;
3294 |  |
                 case 3: jj_3_4(); break;
3295 |  |
                 case 4: jj_3_5(); break;
3296 |  |
                 case 5: jj_3_6(); break;
3297 |  |
                 case 6: jj_3_7(); break;
3298 |  |
                 case 7: jj_3_8(); break;
3299 |  |
                 case 8: jj_3_9(); break;
3300 |  |
               }
3301 |  |
             }
3302 |  |
             p = p.next;
3303 |  |
           } while (p != null);
3304 |  |
         }
3305 |  |
         jj_rescan = false;
3306 |  |
       }
3307 |  |
3308 |  |
       final private void jj_save(int index, class="keyword">int xla) {
3309 |  |
         JJCalls p = jj_2_rtns[index];
3310 |  |
         while (p.gen > jj_gen) {
3311 |  |
           if (p.next == null) { p = p.next = new JJCalls(); break; }
3312 |  |
           p = p.next;
3313 |  |
         }
3314 |  |
         p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3315 |  |
       }
3316 |  |
3317 | 26067 |
       static final class JJCalls {
3318 |  |
         int gen;
3319 |  |
         Token first;
3320 |  |
         int arg;
3321 |  |
         JJCalls next;
3322 |  |
       }
3323 |  |
3324 |  |
     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.