KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > objectweb > jonas_ejb > deployment > ejbql > EJBQL


1 /* Generated By:JJTree&JavaCC: Do not edit this line. EJBQL.java */
2 package org.objectweb.jonas_ejb.deployment.ejbql;
3
4 public class EJBQL/*@bgen(jjtree)*/implements EJBQLTreeConstants, EJBQLConstants {/*@bgen(jjtree)*/
5   protected JJTEJBQLState jjtree = new JJTEJBQLState();
6
7   final public SimpleNode EJBQL() throws ParseException {
8  /*@bgen(jjtree) EJBQL */
9   ASTEJBQL jjtn000 = new ASTEJBQL(JJTEJBQL);
10   boolean jjtc000 = true;
11   jjtree.openNodeScope(jjtn000);
12     try {
13       SelectClause();
14       FromClause();
15       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
16       case WHERE:
17         WhereClause();
18         break;
19       default:
20         jj_la1[0] = jj_gen;
21         ;
22       }
23       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
24       case ORDERBY:
25         OrderByClause();
26         break;
27       default:
28         jj_la1[1] = jj_gen;
29         ;
30       }
31       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
32       case LIMIT:
33         LimitClause();
34         break;
35       default:
36         jj_la1[2] = jj_gen;
37         ;
38       }
39       jj_consume_token(0);
40    jjtree.closeNodeScope(jjtn000, true);
41    jjtc000 = false;
42    {if (true) return jjtn000;}
43     } catch (Throwable JavaDoc jjte000) {
44    if (jjtc000) {
45      jjtree.clearNodeScope(jjtn000);
46      jjtc000 = false;
47    } else {
48      jjtree.popNode();
49    }
50    if (jjte000 instanceof RuntimeException JavaDoc) {
51      {if (true) throw (RuntimeException JavaDoc)jjte000;}
52    }
53    if (jjte000 instanceof ParseException) {
54      {if (true) throw (ParseException)jjte000;}
55    }
56    {if (true) throw (Error JavaDoc)jjte000;}
57     } finally {
58    if (jjtc000) {
59      jjtree.closeNodeScope(jjtn000, true);
60    }
61     }
62     throw new Error JavaDoc("Missing return statement in function");
63   }
64
65   final public void FromClause() throws ParseException {
66  /*@bgen(jjtree) FromClause */
67   ASTFromClause jjtn000 = new ASTFromClause(JJTFROMCLAUSE);
68   boolean jjtc000 = true;
69   jjtree.openNodeScope(jjtn000);
70     try {
71       jj_consume_token(FROM);
72       IdentificationVariableDeclaration();
73       label_1:
74       while (true) {
75         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
76         case COMMA:
77           ;
78           break;
79         default:
80           jj_la1[3] = jj_gen;
81           break label_1;
82         }
83         jj_consume_token(COMMA);
84         IdentificationVariableDeclaration();
85       }
86     } catch (Throwable JavaDoc jjte000) {
87    if (jjtc000) {
88      jjtree.clearNodeScope(jjtn000);
89      jjtc000 = false;
90    } else {
91      jjtree.popNode();
92    }
93    if (jjte000 instanceof RuntimeException JavaDoc) {
94      {if (true) throw (RuntimeException JavaDoc)jjte000;}
95    }
96    if (jjte000 instanceof ParseException) {
97      {if (true) throw (ParseException)jjte000;}
98    }
99    {if (true) throw (Error JavaDoc)jjte000;}
100     } finally {
101    if (jjtc000) {
102      jjtree.closeNodeScope(jjtn000, true);
103    }
104     }
105   }
106
107   final public void IdentificationVariableDeclaration() throws ParseException {
108     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
109     case IN:
110       CollectionMemberDeclaration();
111       break;
112     case IDENTIFIER:
113       RangeVariableDeclaration();
114       break;
115     default:
116       jj_la1[4] = jj_gen;
117       jj_consume_token(-1);
118       throw new ParseException();
119     }
120   }
121
122   final public void CollectionMemberDeclaration() throws ParseException {
123  /*@bgen(jjtree) CollectionMemberDeclaration */
124   ASTCollectionMemberDeclaration jjtn000 = new ASTCollectionMemberDeclaration(JJTCOLLECTIONMEMBERDECLARATION);
125   boolean jjtc000 = true;
126   jjtree.openNodeScope(jjtn000);
127     try {
128       jj_consume_token(IN);
129       jj_consume_token(LPAREN);
130       CollectionValuedPathExpression();
131       jj_consume_token(RPAREN);
132       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
133       case AS:
134         jj_consume_token(AS);
135         break;
136       default:
137         jj_la1[5] = jj_gen;
138         ;
139       }
140       Identifier();
141     } catch (Throwable JavaDoc jjte000) {
142    if (jjtc000) {
143      jjtree.clearNodeScope(jjtn000);
144      jjtc000 = false;
145    } else {
146      jjtree.popNode();
147    }
148    if (jjte000 instanceof RuntimeException JavaDoc) {
149      {if (true) throw (RuntimeException JavaDoc)jjte000;}
150    }
151    if (jjte000 instanceof ParseException) {
152      {if (true) throw (ParseException)jjte000;}
153    }
154    {if (true) throw (Error JavaDoc)jjte000;}
155     } finally {
156    if (jjtc000) {
157      jjtree.closeNodeScope(jjtn000, true);
158    }
159     }
160   }
161
162   final public void RangeVariableDeclaration() throws ParseException {
163  /*@bgen(jjtree) RangeVariableDeclaration */
164   ASTRangeVariableDeclaration jjtn000 = new ASTRangeVariableDeclaration(JJTRANGEVARIABLEDECLARATION);
165   boolean jjtc000 = true;
166   jjtree.openNodeScope(jjtn000);
167     try {
168       AbstractSchemaName();
169       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
170       case AS:
171         jj_consume_token(AS);
172         break;
173       default:
174         jj_la1[6] = jj_gen;
175         ;
176       }
177       Identifier();
178     } catch (Throwable JavaDoc jjte000) {
179    if (jjtc000) {
180      jjtree.clearNodeScope(jjtn000);
181      jjtc000 = false;
182    } else {
183      jjtree.popNode();
184    }
185    if (jjte000 instanceof RuntimeException JavaDoc) {
186      {if (true) throw (RuntimeException JavaDoc)jjte000;}
187    }
188    if (jjte000 instanceof ParseException) {
189      {if (true) throw (ParseException)jjte000;}
190    }
191    {if (true) throw (Error JavaDoc)jjte000;}
192     } finally {
193    if (jjtc000) {
194      jjtree.closeNodeScope(jjtn000, true);
195    }
196     }
197   }
198
199   final public void SingleValuedPathExpression() throws ParseException {
200  /*@bgen(jjtree) SingleValuedPathExpression */
201   ASTSingleValuedPathExpression jjtn000 = new ASTSingleValuedPathExpression(JJTSINGLEVALUEDPATHEXPRESSION);
202   boolean jjtc000 = true;
203   jjtree.openNodeScope(jjtn000);
204     try {
205       Path();
206     } catch (Throwable JavaDoc jjte000) {
207    if (jjtc000) {
208      jjtree.clearNodeScope(jjtn000);
209      jjtc000 = false;
210    } else {
211      jjtree.popNode();
212    }
213    if (jjte000 instanceof RuntimeException JavaDoc) {
214      {if (true) throw (RuntimeException JavaDoc)jjte000;}
215    }
216    if (jjte000 instanceof ParseException) {
217      {if (true) throw (ParseException)jjte000;}
218    }
219    {if (true) throw (Error JavaDoc)jjte000;}
220     } finally {
221    if (jjtc000) {
222      jjtree.closeNodeScope(jjtn000, true);
223    }
224     }
225   }
226
227   final public void CmpPathExpression() throws ParseException {
228  /*@bgen(jjtree) CmpPathExpression */
229   ASTCmpPathExpression jjtn000 = new ASTCmpPathExpression(JJTCMPPATHEXPRESSION);
230   boolean jjtc000 = true;
231   jjtree.openNodeScope(jjtn000);
232     try {
233       Path();
234     } catch (Throwable JavaDoc jjte000) {
235    if (jjtc000) {
236      jjtree.clearNodeScope(jjtn000);
237      jjtc000 = false;
238    } else {
239      jjtree.popNode();
240    }
241    if (jjte000 instanceof RuntimeException JavaDoc) {
242      {if (true) throw (RuntimeException JavaDoc)jjte000;}
243    }
244    if (jjte000 instanceof ParseException) {
245      {if (true) throw (ParseException)jjte000;}
246    }
247    {if (true) throw (Error JavaDoc)jjte000;}
248     } finally {
249    if (jjtc000) {
250      jjtree.closeNodeScope(jjtn000, true);
251    }
252     }
253   }
254
255   final public void SingleValuedCmrPathExpression() throws ParseException {
256  /*@bgen(jjtree) SingleValuedCmrPathExpression */
257   ASTSingleValuedCmrPathExpression jjtn000 = new ASTSingleValuedCmrPathExpression(JJTSINGLEVALUEDCMRPATHEXPRESSION);
258   boolean jjtc000 = true;
259   jjtree.openNodeScope(jjtn000);
260     try {
261       Path();
262     } catch (Throwable JavaDoc jjte000) {
263    if (jjtc000) {
264      jjtree.clearNodeScope(jjtn000);
265      jjtc000 = false;
266    } else {
267      jjtree.popNode();
268    }
269    if (jjte000 instanceof RuntimeException JavaDoc) {
270      {if (true) throw (RuntimeException JavaDoc)jjte000;}
271    }
272    if (jjte000 instanceof ParseException) {
273      {if (true) throw (ParseException)jjte000;}
274    }
275    {if (true) throw (Error JavaDoc)jjte000;}
276     } finally {
277    if (jjtc000) {
278      jjtree.closeNodeScope(jjtn000, true);
279    }
280     }
281   }
282
283   final public void CollectionValuedPathExpression() throws ParseException {
284  /*@bgen(jjtree) CollectionValuedPathExpression */
285   ASTCollectionValuedPathExpression jjtn000 = new ASTCollectionValuedPathExpression(JJTCOLLECTIONVALUEDPATHEXPRESSION);
286   boolean jjtc000 = true;
287   jjtree.openNodeScope(jjtn000);
288     try {
289       Path();
290     } catch (Throwable JavaDoc jjte000) {
291    if (jjtc000) {
292      jjtree.clearNodeScope(jjtn000);
293      jjtc000 = false;
294    } else {
295      jjtree.popNode();
296    }
297    if (jjte000 instanceof RuntimeException JavaDoc) {
298      {if (true) throw (RuntimeException JavaDoc)jjte000;}
299    }
300    if (jjte000 instanceof ParseException) {
301      {if (true) throw (ParseException)jjte000;}
302    }
303    {if (true) throw (Error JavaDoc)jjte000;}
304     } finally {
305    if (jjtc000) {
306      jjtree.closeNodeScope(jjtn000, true);
307    }
308     }
309   }
310
311   final public void SelectClause() throws ParseException {
312  /*@bgen(jjtree) SelectClause */
313   ASTSelectClause jjtn000 = new ASTSelectClause(JJTSELECTCLAUSE);
314   boolean jjtc000 = true;
315   jjtree.openNodeScope(jjtn000);
316     try {
317       jj_consume_token(SELECT);
318       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
319       case DISTINCT:
320         jj_consume_token(DISTINCT);
321                        jjtn000.distinct=true;
322         break;
323       default:
324         jj_la1[7] = jj_gen;
325         ;
326       }
327       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
328       case AVG:
329       case COUNT:
330       case MAX:
331       case MIN:
332       case SUM:
333       case IDENTIFIER:
334         SelectExpression();
335         break;
336       case OBJECT:
337         jj_consume_token(OBJECT);
338         jj_consume_token(LPAREN);
339         IdentificationVariable();
340         jj_consume_token(RPAREN);
341         break;
342       default:
343         jj_la1[8] = jj_gen;
344         jj_consume_token(-1);
345         throw new ParseException();
346       }
347     } catch (Throwable JavaDoc jjte000) {
348    if (jjtc000) {
349      jjtree.clearNodeScope(jjtn000);
350      jjtc000 = false;
351    } else {
352      jjtree.popNode();
353    }
354    if (jjte000 instanceof RuntimeException JavaDoc) {
355      {if (true) throw (RuntimeException JavaDoc)jjte000;}
356    }
357    if (jjte000 instanceof ParseException) {
358      {if (true) throw (ParseException)jjte000;}
359    }
360    {if (true) throw (Error JavaDoc)jjte000;}
361     } finally {
362    if (jjtc000) {
363      jjtree.closeNodeScope(jjtn000, true);
364    }
365     }
366   }
367
368   final public void SelectExpression() throws ParseException {
369  /*@bgen(jjtree) SelectExpression */
370   ASTSelectExpression jjtn000 = new ASTSelectExpression(JJTSELECTEXPRESSION);
371   boolean jjtc000 = true;
372   jjtree.openNodeScope(jjtn000);
373     try {
374       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
375       case IDENTIFIER:
376         SingleValuedPathExpression();
377         break;
378       case AVG:
379       case COUNT:
380       case MAX:
381       case MIN:
382       case SUM:
383         AggregateSelectExpression();
384         break;
385       default:
386         jj_la1[9] = jj_gen;
387         jj_consume_token(-1);
388         throw new ParseException();
389       }
390     } catch (Throwable JavaDoc jjte000) {
391     if (jjtc000) {
392       jjtree.clearNodeScope(jjtn000);
393       jjtc000 = false;
394     } else {
395       jjtree.popNode();
396     }
397     if (jjte000 instanceof RuntimeException JavaDoc) {
398       {if (true) throw (RuntimeException JavaDoc)jjte000;}
399     }
400     if (jjte000 instanceof ParseException) {
401       {if (true) throw (ParseException)jjte000;}
402     }
403     {if (true) throw (Error JavaDoc)jjte000;}
404     } finally {
405     if (jjtc000) {
406       jjtree.closeNodeScope(jjtn000, true);
407     }
408     }
409   }
410
411   final public void AggregateSelectExpression() throws ParseException {
412  /*@bgen(jjtree) AggregateSelectExpression */
413   ASTAggregateSelectExpression jjtn000 = new ASTAggregateSelectExpression(JJTAGGREGATESELECTEXPRESSION);
414   boolean jjtc000 = true;
415   jjtree.openNodeScope(jjtn000);Token t;
416     try {
417       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
418       case AVG:
419       case MAX:
420       case MIN:
421       case SUM:
422         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
423         case AVG:
424           t = jj_consume_token(AVG);
425           break;
426         case MAX:
427           t = jj_consume_token(MAX);
428           break;
429         case MIN:
430           t = jj_consume_token(MIN);
431           break;
432         case SUM:
433           t = jj_consume_token(SUM);
434           break;
435         default:
436           jj_la1[10] = jj_gen;
437           jj_consume_token(-1);
438           throw new ParseException();
439         }
440                                              jjtn000.ops.add(new Integer JavaDoc(t.kind));
441         jj_consume_token(LPAREN);
442         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
443         case DISTINCT:
444           jj_consume_token(DISTINCT);
445                   jjtn000.distinct=true;
446           break;
447         default:
448           jj_la1[11] = jj_gen;
449           ;
450         }
451         CmpPathExpression();
452         jj_consume_token(RPAREN);
453         break;
454       case COUNT:
455         t = jj_consume_token(COUNT);
456                  jjtn000.ops.add(new Integer JavaDoc(t.kind));
457         jj_consume_token(LPAREN);
458         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
459         case DISTINCT:
460           jj_consume_token(DISTINCT);
461                   jjtn000.distinct=true;
462           break;
463         default:
464           jj_la1[12] = jj_gen;
465           ;
466         }
467         if (jj_2_1(2147483647)) {
468           SingleValuedPathExpression();
469         } else {
470           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
471           case IDENTIFIER:
472             IdentificationVariable();
473             break;
474           default:
475             jj_la1[13] = jj_gen;
476             jj_consume_token(-1);
477             throw new ParseException();
478           }
479         }
480         jj_consume_token(RPAREN);
481         break;
482       default:
483         jj_la1[14] = jj_gen;
484         jj_consume_token(-1);
485         throw new ParseException();
486       }
487     } catch (Throwable JavaDoc jjte000) {
488     if (jjtc000) {
489       jjtree.clearNodeScope(jjtn000);
490       jjtc000 = false;
491     } else {
492       jjtree.popNode();
493     }
494     if (jjte000 instanceof RuntimeException JavaDoc) {
495       {if (true) throw (RuntimeException JavaDoc)jjte000;}
496     }
497     if (jjte000 instanceof ParseException) {
498       {if (true) throw (ParseException)jjte000;}
499     }
500     {if (true) throw (Error JavaDoc)jjte000;}
501     } finally {
502     if (jjtc000) {
503       jjtree.closeNodeScope(jjtn000, true);
504     }
505     }
506   }
507
508   final public void OrderByClause() throws ParseException {
509  /*@bgen(jjtree) OrderByClause */
510   ASTOrderByClause jjtn000 = new ASTOrderByClause(JJTORDERBYCLAUSE);
511   boolean jjtc000 = true;
512   jjtree.openNodeScope(jjtn000);
513     try {
514       jj_consume_token(ORDERBY);
515       OrderByItem();
516       label_2:
517       while (true) {
518         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
519         case COMMA:
520           ;
521           break;
522         default:
523           jj_la1[15] = jj_gen;
524           break label_2;
525         }
526         jj_consume_token(COMMA);
527         OrderByItem();
528       }
529     } catch (Throwable JavaDoc jjte000) {
530    if (jjtc000) {
531      jjtree.clearNodeScope(jjtn000);
532      jjtc000 = false;
533    } else {
534      jjtree.popNode();
535    }
536    if (jjte000 instanceof RuntimeException JavaDoc) {
537      {if (true) throw (RuntimeException JavaDoc)jjte000;}
538    }
539    if (jjte000 instanceof ParseException) {
540      {if (true) throw (ParseException)jjte000;}
541    }
542    {if (true) throw (Error JavaDoc)jjte000;}
543     } finally {
544    if (jjtc000) {
545      jjtree.closeNodeScope(jjtn000, true);
546    }
547     }
548   }
549
550   final public void OrderByItem() throws ParseException {
551  /*@bgen(jjtree) OrderByItem */
552   ASTOrderByItem jjtn000 = new ASTOrderByItem(JJTORDERBYITEM);
553   boolean jjtc000 = true;
554   jjtree.openNodeScope(jjtn000);
555     try {
556       CmpPathExpression();
557       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
558       case ASC:
559       case DESC:
560         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
561         case ASC:
562           jj_consume_token(ASC);
563                               jjtn000.asc=true;
564           break;
565         case DESC:
566           jj_consume_token(DESC);
567                                                           jjtn000.asc=false;
568           break;
569         default:
570           jj_la1[16] = jj_gen;
571           jj_consume_token(-1);
572           throw new ParseException();
573         }
574         break;
575       default:
576         jj_la1[17] = jj_gen;
577         ;
578       }
579     } catch (Throwable JavaDoc jjte000) {
580    if (jjtc000) {
581      jjtree.clearNodeScope(jjtn000);
582      jjtc000 = false;
583    } else {
584      jjtree.popNode();
585    }
586    if (jjte000 instanceof RuntimeException JavaDoc) {
587      {if (true) throw (RuntimeException JavaDoc)jjte000;}
588    }
589    if (jjte000 instanceof ParseException) {
590      {if (true) throw (ParseException)jjte000;}
591    }
592    {if (true) throw (Error JavaDoc)jjte000;}
593     } finally {
594    if (jjtc000) {
595      jjtree.closeNodeScope(jjtn000, true);
596    }
597     }
598   }
599
600   final public void LimitClause() throws ParseException {
601  /*@bgen(jjtree) LimitClause */
602   ASTLimitClause jjtn000 = new ASTLimitClause(JJTLIMITCLAUSE);
603   boolean jjtc000 = true;
604   jjtree.openNodeScope(jjtn000);
605     try {
606       jj_consume_token(LIMIT);
607       LimitExpression();
608       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
609       case COMMA:
610         jj_consume_token(COMMA);
611         LimitExpression();
612         break;
613       default:
614         jj_la1[18] = jj_gen;
615         ;
616       }
617     } catch (Throwable JavaDoc jjte000) {
618    if (jjtc000) {
619      jjtree.clearNodeScope(jjtn000);
620      jjtc000 = false;
621    } else {
622      jjtree.popNode();
623    }
624    if (jjte000 instanceof RuntimeException JavaDoc) {
625      {if (true) throw (RuntimeException JavaDoc)jjte000;}
626    }
627    if (jjte000 instanceof ParseException) {
628      {if (true) throw (ParseException)jjte000;}
629    }
630    {if (true) throw (Error JavaDoc)jjte000;}
631     } finally {
632    if (jjtc000) {
633      jjtree.closeNodeScope(jjtn000, true);
634    }
635     }
636   }
637
638   final public void LimitExpression() throws ParseException {
639  /*@bgen(jjtree) LimitExpression */
640   ASTLimitExpression jjtn000 = new ASTLimitExpression(JJTLIMITEXPRESSION);
641   boolean jjtc000 = true;
642   jjtree.openNodeScope(jjtn000);
643     try {
644       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
645       case INTEGER_LITERAL:
646         IntegerLiteral();
647         break;
648       case input_parameter:
649         InputParameter();
650         break;
651       default:
652         jj_la1[19] = jj_gen;
653         jj_consume_token(-1);
654         throw new ParseException();
655       }
656     } catch (Throwable JavaDoc jjte000) {
657    if (jjtc000) {
658      jjtree.clearNodeScope(jjtn000);
659      jjtc000 = false;
660    } else {
661      jjtree.popNode();
662    }
663    if (jjte000 instanceof RuntimeException JavaDoc) {
664      {if (true) throw (RuntimeException JavaDoc)jjte000;}
665    }
666    if (jjte000 instanceof ParseException) {
667      {if (true) throw (ParseException)jjte000;}
668    }
669    {if (true) throw (Error JavaDoc)jjte000;}
670     } finally {
671    if (jjtc000) {
672      jjtree.closeNodeScope(jjtn000, true);
673    }
674     }
675   }
676
677   final public void WhereClause() throws ParseException {
678  /*@bgen(jjtree) WhereClause */
679   ASTWhereClause jjtn000 = new ASTWhereClause(JJTWHERECLAUSE);
680   boolean jjtc000 = true;
681   jjtree.openNodeScope(jjtn000);
682     try {
683       jj_consume_token(WHERE);
684       ConditionalExpression();
685     } catch (Throwable JavaDoc jjte000) {
686    if (jjtc000) {
687      jjtree.clearNodeScope(jjtn000);
688      jjtc000 = false;
689    } else {
690      jjtree.popNode();
691    }
692    if (jjte000 instanceof RuntimeException JavaDoc) {
693      {if (true) throw (RuntimeException JavaDoc)jjte000;}
694    }
695    if (jjte000 instanceof ParseException) {
696      {if (true) throw (ParseException)jjte000;}
697    }
698    {if (true) throw (Error JavaDoc)jjte000;}
699     } finally {
700    if (jjtc000) {
701      jjtree.closeNodeScope(jjtn000, true);
702    }
703     }
704   }
705
706   final public void ConditionalExpression() throws ParseException {
707  /*@bgen(jjtree) ConditionalExpression */
708   ASTConditionalExpression jjtn000 = new ASTConditionalExpression(JJTCONDITIONALEXPRESSION);
709   boolean jjtc000 = true;
710   jjtree.openNodeScope(jjtn000);
711     try {
712       ConditionalTerm();
713       label_3:
714       while (true) {
715         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
716         case OR:
717           ;
718           break;
719         default:
720           jj_la1[20] = jj_gen;
721           break label_3;
722         }
723         jj_consume_token(OR);
724         ConditionalTerm();
725       }
726     } catch (Throwable JavaDoc jjte000) {
727    if (jjtc000) {
728      jjtree.clearNodeScope(jjtn000);
729      jjtc000 = false;
730    } else {
731      jjtree.popNode();
732    }
733    if (jjte000 instanceof RuntimeException JavaDoc) {
734      {if (true) throw (RuntimeException JavaDoc)jjte000;}
735    }
736    if (jjte000 instanceof ParseException) {
737      {if (true) throw (ParseException)jjte000;}
738    }
739    {if (true) throw (Error JavaDoc)jjte000;}
740     } finally {
741    if (jjtc000) {
742      jjtree.closeNodeScope(jjtn000, true);
743    }
744     }
745   }
746
747   final public void ConditionalTerm() throws ParseException {
748  /*@bgen(jjtree) ConditionalTerm */
749   ASTConditionalTerm jjtn000 = new ASTConditionalTerm(JJTCONDITIONALTERM);
750   boolean jjtc000 = true;
751   jjtree.openNodeScope(jjtn000);
752     try {
753       ConditionalFactor();
754       label_4:
755       while (true) {
756         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
757         case AND:
758           ;
759           break;
760         default:
761           jj_la1[21] = jj_gen;
762           break label_4;
763         }
764         jj_consume_token(AND);
765         ConditionalFactor();
766       }
767     } catch (Throwable JavaDoc jjte000) {
768    if (jjtc000) {
769      jjtree.clearNodeScope(jjtn000);
770      jjtc000 = false;
771    } else {
772      jjtree.popNode();
773    }
774    if (jjte000 instanceof RuntimeException JavaDoc) {
775      {if (true) throw (RuntimeException JavaDoc)jjte000;}
776    }
777    if (jjte000 instanceof ParseException) {
778      {if (true) throw (ParseException)jjte000;}
779    }
780    {if (true) throw (Error JavaDoc)jjte000;}
781     } finally {
782    if (jjtc000) {
783      jjtree.closeNodeScope(jjtn000, true);
784    }
785     }
786   }
787
788   final public void ConditionalFactor() throws ParseException {
789  /*@bgen(jjtree) ConditionalFactor */
790   ASTConditionalFactor jjtn000 = new ASTConditionalFactor(JJTCONDITIONALFACTOR);
791   boolean jjtc000 = true;
792   jjtree.openNodeScope(jjtn000);
793     try {
794       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
795       case NOT:
796         jj_consume_token(NOT);
797           jjtn000.not=true;
798         break;
799       default:
800         jj_la1[22] = jj_gen;
801         ;
802       }
803       ConditionalPrimary();
804     } catch (Throwable JavaDoc jjte000) {
805    if (jjtc000) {
806      jjtree.clearNodeScope(jjtn000);
807      jjtc000 = false;
808    } else {
809      jjtree.popNode();
810    }
811    if (jjte000 instanceof RuntimeException JavaDoc) {
812      {if (true) throw (RuntimeException JavaDoc)jjte000;}
813    }
814    if (jjte000 instanceof ParseException) {
815      {if (true) throw (ParseException)jjte000;}
816    }
817    {if (true) throw (Error JavaDoc)jjte000;}
818     } finally {
819    if (jjtc000) {
820      jjtree.closeNodeScope(jjtn000, true);
821    }
822     }
823   }
824
825   final public void ConditionalPrimary() throws ParseException {
826     if (jj_2_2(2147483647)) {
827       SimpleCondExpression();
828     } else if (jj_2_3(2147483647)) {
829       jj_consume_token(LPAREN);
830       ConditionalExpression();
831       jj_consume_token(RPAREN);
832     } else {
833       jj_consume_token(-1);
834       throw new ParseException();
835     }
836   }
837
838   final public void SimpleCondExpression() throws ParseException {
839     if (jj_2_4(2147483647)) {
840       ComparisonExpression();
841     } else if (jj_2_5(2147483647)) {
842       BetweenExpression();
843     } else if (jj_2_6(2147483647)) {
844       LikeExpression();
845     } else if (jj_2_7(2147483647)) {
846       InExpression();
847     } else if (jj_2_8(2147483647)) {
848       NullComparisonExpression();
849     } else if (jj_2_9(2147483647)) {
850       EmptyCollectionComparisonExpression();
851     } else if (jj_2_10(2147483647)) {
852       CollectionMemberExpression();
853     } else {
854       jj_consume_token(-1);
855       throw new ParseException();
856     }
857   }
858
859   final public void BetweenExpression() throws ParseException {
860  /*@bgen(jjtree) BetweenExpression */
861   ASTBetweenExpression jjtn000 = new ASTBetweenExpression(JJTBETWEENEXPRESSION);
862   boolean jjtc000 = true;
863   jjtree.openNodeScope(jjtn000);
864     try {
865       ArithmeticExpression();
866       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
867       case NOT:
868         jj_consume_token(NOT);
869                                   jjtn000.not=true;
870         break;
871       default:
872         jj_la1[23] = jj_gen;
873         ;
874       }
875       jj_consume_token(BETWEEN);
876       ArithmeticExpression();
877       jj_consume_token(AND);
878       ArithmeticExpression();
879     } catch (Throwable JavaDoc jjte000) {
880    if (jjtc000) {
881      jjtree.clearNodeScope(jjtn000);
882      jjtc000 = false;
883    } else {
884      jjtree.popNode();
885    }
886    if (jjte000 instanceof RuntimeException JavaDoc) {
887      {if (true) throw (RuntimeException JavaDoc)jjte000;}
888    }
889    if (jjte000 instanceof ParseException) {
890      {if (true) throw (ParseException)jjte000;}
891    }
892    {if (true) throw (Error JavaDoc)jjte000;}
893     } finally {
894    if (jjtc000) {
895      jjtree.closeNodeScope(jjtn000, true);
896    }
897     }
898   }
899
900   final public void InExpression() throws ParseException {
901  /*@bgen(jjtree) InExpression */
902   ASTInExpression jjtn000 = new ASTInExpression(JJTINEXPRESSION);
903   boolean jjtc000 = true;
904   jjtree.openNodeScope(jjtn000);
905     try {
906       CmpPathExpression();
907       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
908       case NOT:
909         jj_consume_token(NOT);
910                                jjtn000.not=true;
911         break;
912       default:
913         jj_la1[24] = jj_gen;
914         ;
915       }
916       jj_consume_token(IN);
917       jj_consume_token(LPAREN);
918       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
919       case string_literal:
920       case FALSE:
921       case TRUE:
922       case INTEGER_LITERAL:
923       case FLOATING_POINT_LITERAL:
924         Literal();
925         break;
926       case input_parameter:
927         InputParameter();
928         break;
929       default:
930         jj_la1[25] = jj_gen;
931         jj_consume_token(-1);
932         throw new ParseException();
933       }
934                                                    jjtn000.eltnum=1;
935       label_5:
936       while (true) {
937         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
938         case COMMA:
939           ;
940           break;
941         default:
942           jj_la1[26] = jj_gen;
943           break label_5;
944         }
945         jj_consume_token(COMMA);
946         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
947         case string_literal:
948         case FALSE:
949         case TRUE:
950         case INTEGER_LITERAL:
951         case FLOATING_POINT_LITERAL:
952           Literal();
953           break;
954         case input_parameter:
955           InputParameter();
956           break;
957         default:
958           jj_la1[27] = jj_gen;
959           jj_consume_token(-1);
960           throw new ParseException();
961         }
962                                                     jjtn000.eltnum++;
963       }
964       jj_consume_token(RPAREN);
965     } catch (Throwable JavaDoc jjte000) {
966    if (jjtc000) {
967      jjtree.clearNodeScope(jjtn000);
968      jjtc000 = false;
969    } else {
970      jjtree.popNode();
971    }
972    if (jjte000 instanceof RuntimeException JavaDoc) {
973      {if (true) throw (RuntimeException JavaDoc)jjte000;}
974    }
975    if (jjte000 instanceof ParseException) {
976      {if (true) throw (ParseException)jjte000;}
977    }
978    {if (true) throw (Error JavaDoc)jjte000;}
979     } finally {
980    if (jjtc000) {
981      jjtree.closeNodeScope(jjtn000, true);
982    }
983     }
984   }
985
986   final public void LikeExpression() throws ParseException {
987  /*@bgen(jjtree) LikeExpression */
988   ASTLikeExpression jjtn000 = new ASTLikeExpression(JJTLIKEEXPRESSION);
989   boolean jjtc000 = true;
990   jjtree.openNodeScope(jjtn000);
991     try {
992       CmpPathExpression();
993       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
994       case NOT:
995         jj_consume_token(NOT);
996                                jjtn000.not=true;
997         break;
998       default:
999         jj_la1[28] = jj_gen;
1000        ;
1001      }
1002      jj_consume_token(LIKE);
1003      PatternValue();
1004      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1005      case ESCAPE:
1006        jj_consume_token(ESCAPE);
1007                                       jjtn000.third=true;
1008        EscapeCharacter();
1009        break;
1010      default:
1011        jj_la1[29] = jj_gen;
1012        ;
1013      }
1014    } catch (Throwable JavaDoc jjte000) {
1015   if (jjtc000) {
1016     jjtree.clearNodeScope(jjtn000);
1017     jjtc000 = false;
1018   } else {
1019     jjtree.popNode();
1020   }
1021   if (jjte000 instanceof RuntimeException JavaDoc) {
1022     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1023   }
1024   if (jjte000 instanceof ParseException) {
1025     {if (true) throw (ParseException)jjte000;}
1026   }
1027   {if (true) throw (Error JavaDoc)jjte000;}
1028    } finally {
1029   if (jjtc000) {
1030     jjtree.closeNodeScope(jjtn000, true);
1031   }
1032    }
1033  }
1034
1035  final public void NullComparisonExpression() throws ParseException {
1036 /*@bgen(jjtree) NullComparisonExpression */
1037  ASTNullComparisonExpression jjtn000 = new ASTNullComparisonExpression(JJTNULLCOMPARISONEXPRESSION);
1038  boolean jjtc000 = true;
1039  jjtree.openNodeScope(jjtn000);
1040    try {
1041      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1042      case IDENTIFIER:
1043        SingleValuedPathExpression();
1044        break;
1045      case input_parameter:
1046        InputParameter();
1047        break;
1048      default:
1049        jj_la1[30] = jj_gen;
1050        jj_consume_token(-1);
1051        throw new ParseException();
1052      }
1053      jj_consume_token(IS);
1054      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1055      case NOT:
1056        jj_consume_token(NOT);
1057              jjtn000.not=true;
1058        break;
1059      default:
1060        jj_la1[31] = jj_gen;
1061        ;
1062      }
1063      jj_consume_token(NULL);
1064    } catch (Throwable JavaDoc jjte000) {
1065   if (jjtc000) {
1066     jjtree.clearNodeScope(jjtn000);
1067     jjtc000 = false;
1068   } else {
1069     jjtree.popNode();
1070   }
1071   if (jjte000 instanceof RuntimeException JavaDoc) {
1072     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1073   }
1074   if (jjte000 instanceof ParseException) {
1075     {if (true) throw (ParseException)jjte000;}
1076   }
1077   {if (true) throw (Error JavaDoc)jjte000;}
1078    } finally {
1079   if (jjtc000) {
1080     jjtree.closeNodeScope(jjtn000, true);
1081   }
1082    }
1083  }
1084
1085  final public void EmptyCollectionComparisonExpression() throws ParseException {
1086 /*@bgen(jjtree) EmptyCollectionComparisonExpression */
1087  ASTEmptyCollectionComparisonExpression jjtn000 = new ASTEmptyCollectionComparisonExpression(JJTEMPTYCOLLECTIONCOMPARISONEXPRESSION);
1088  boolean jjtc000 = true;
1089  jjtree.openNodeScope(jjtn000);
1090    try {
1091      CollectionValuedPathExpression();
1092      jj_consume_token(IS);
1093      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1094      case NOT:
1095        jj_consume_token(NOT);
1096              jjtn000.not=true;
1097        break;
1098      default:
1099        jj_la1[32] = jj_gen;
1100        ;
1101      }
1102      jj_consume_token(EMPTY);
1103    } catch (Throwable JavaDoc jjte000) {
1104   if (jjtc000) {
1105     jjtree.clearNodeScope(jjtn000);
1106     jjtc000 = false;
1107   } else {
1108     jjtree.popNode();
1109   }
1110   if (jjte000 instanceof RuntimeException JavaDoc) {
1111     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1112   }
1113   if (jjte000 instanceof ParseException) {
1114     {if (true) throw (ParseException)jjte000;}
1115   }
1116   {if (true) throw (Error JavaDoc)jjte000;}
1117    } finally {
1118   if (jjtc000) {
1119     jjtree.closeNodeScope(jjtn000, true);
1120   }
1121    }
1122  }
1123
1124  final public void CollectionMemberExpression() throws ParseException {
1125 /*@bgen(jjtree) CollectionMemberExpression */
1126  ASTCollectionMemberExpression jjtn000 = new ASTCollectionMemberExpression(JJTCOLLECTIONMEMBEREXPRESSION);
1127  boolean jjtc000 = true;
1128  jjtree.openNodeScope(jjtn000);
1129    try {
1130      if (jj_2_11(2)) {
1131        SingleValuedCmrPathExpression();
1132      } else if (jj_2_12(2)) {
1133        IdentificationVariable();
1134      } else {
1135        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1136        case input_parameter:
1137          InputParameter();
1138          break;
1139        default:
1140          jj_la1[33] = jj_gen;
1141          jj_consume_token(-1);
1142          throw new ParseException();
1143        }
1144      }
1145      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1146      case NOT:
1147        jj_consume_token(NOT);
1148             jjtn000.not=true;
1149        break;
1150      default:
1151        jj_la1[34] = jj_gen;
1152        ;
1153      }
1154      jj_consume_token(MEMBER);
1155      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1156      case OF:
1157        jj_consume_token(OF);
1158        break;
1159      default:
1160        jj_la1[35] = jj_gen;
1161        ;
1162      }
1163      CollectionValuedPathExpression();
1164    } catch (Throwable JavaDoc jjte000) {
1165   if (jjtc000) {
1166     jjtree.clearNodeScope(jjtn000);
1167     jjtc000 = false;
1168   } else {
1169     jjtree.popNode();
1170   }
1171   if (jjte000 instanceof RuntimeException JavaDoc) {
1172     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1173   }
1174   if (jjte000 instanceof ParseException) {
1175     {if (true) throw (ParseException)jjte000;}
1176   }
1177   {if (true) throw (Error JavaDoc)jjte000;}
1178    } finally {
1179   if (jjtc000) {
1180     jjtree.closeNodeScope(jjtn000, true);
1181   }
1182    }
1183  }
1184
1185  final public void ComparisonExpression() throws ParseException {
1186 /*@bgen(jjtree) ComparisonExpression */
1187 ASTComparisonExpression jjtn000 = new ASTComparisonExpression(JJTCOMPARISONEXPRESSION);
1188 boolean jjtc000 = true;
1189 jjtree.openNodeScope(jjtn000);Token t;
1190    try {
1191      if (jj_2_13(2147483647)) {
1192        StringValue();
1193        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1194        case EQ:
1195          t = jj_consume_token(EQ);
1196          break;
1197        case GT:
1198          t = jj_consume_token(GT);
1199          break;
1200        case GE:
1201          t = jj_consume_token(GE);
1202          break;
1203        case LT:
1204          t = jj_consume_token(LT);
1205          break;
1206        case LE:
1207          t = jj_consume_token(LE);
1208          break;
1209        case NE:
1210          t = jj_consume_token(NE);
1211          break;
1212        default:
1213          jj_la1[36] = jj_gen;
1214          jj_consume_token(-1);
1215          throw new ParseException();
1216        }
1217                                                                    jjtn000.ops.add(new Integer JavaDoc(t.kind));
1218        StringExpression();
1219      } else if (jj_2_14(2147483647)) {
1220        BooleanValue();
1221        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1222        case EQ:
1223          t = jj_consume_token(EQ);
1224          break;
1225        case NE:
1226          t = jj_consume_token(NE);
1227          break;
1228        default:
1229          jj_la1[37] = jj_gen;
1230          jj_consume_token(-1);
1231          throw new ParseException();
1232        }
1233                                    jjtn000.ops.add(new Integer JavaDoc(t.kind));
1234        BooleanExpression();
1235      } else if (jj_2_15(2147483647)) {
1236        DatetimeValue();
1237        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1238        case EQ:
1239          t = jj_consume_token(EQ);
1240          break;
1241        case GT:
1242          t = jj_consume_token(GT);
1243          break;
1244        case GE:
1245          t = jj_consume_token(GE);
1246          break;
1247        case LT:
1248          t = jj_consume_token(LT);
1249          break;
1250        case LE:
1251          t = jj_consume_token(LE);
1252          break;
1253        case NE:
1254          t = jj_consume_token(NE);
1255          break;
1256        default:
1257          jj_la1[38] = jj_gen;
1258          jj_consume_token(-1);
1259          throw new ParseException();
1260        }
1261                                                                      jjtn000.ops.add(new Integer JavaDoc(t.kind));
1262        DatetimeExpression();
1263      } else if (jj_2_16(2147483647)) {
1264        EntityBeanValue();
1265        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1266        case EQ:
1267          t = jj_consume_token(EQ);
1268          break;
1269        case NE:
1270          t = jj_consume_token(NE);
1271          break;
1272        default:
1273          jj_la1[39] = jj_gen;
1274          jj_consume_token(-1);
1275          throw new ParseException();
1276        }
1277                                       jjtn000.ops.add(new Integer JavaDoc(t.kind));
1278        EntityBeanExpression();
1279      } else if (jj_2_17(2147483647)) {
1280        ArithmeticValue();
1281        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1282        case EQ:
1283          t = jj_consume_token(EQ);
1284          break;
1285        case GT:
1286          t = jj_consume_token(GT);
1287          break;
1288        case GE:
1289          t = jj_consume_token(GE);
1290          break;
1291        case LT:
1292          t = jj_consume_token(LT);
1293          break;
1294        case LE:
1295          t = jj_consume_token(LE);
1296          break;
1297        case NE:
1298          t = jj_consume_token(NE);
1299          break;
1300        default:
1301          jj_la1[40] = jj_gen;
1302          jj_consume_token(-1);
1303          throw new ParseException();
1304        }
1305                                                                        jjtn000.ops.add(new Integer JavaDoc(t.kind));
1306        ArithmeticExpression();
1307      } else {
1308        jj_consume_token(-1);
1309        throw new ParseException();
1310      }
1311    } catch (Throwable JavaDoc jjte000) {
1312   if (jjtc000) {
1313     jjtree.clearNodeScope(jjtn000);
1314     jjtc000 = false;
1315   } else {
1316     jjtree.popNode();
1317   }
1318   if (jjte000 instanceof RuntimeException JavaDoc) {
1319     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1320   }
1321   if (jjte000 instanceof ParseException) {
1322     {if (true) throw (ParseException)jjte000;}
1323   }
1324   {if (true) throw (Error JavaDoc)jjte000;}
1325    } finally {
1326   if (jjtc000) {
1327     jjtree.closeNodeScope(jjtn000, true);
1328   }
1329    }
1330  }
1331
1332  final public void ArithmeticValue() throws ParseException {
1333    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1334    case IDENTIFIER:
1335      CmpPathExpression();
1336      break;
1337    case ABS:
1338    case LENGTH:
1339    case LOCATE:
1340    case MOD:
1341    case SQRT:
1342      FunctionsReturningNumerics();
1343      break;
1344    default:
1345      jj_la1[41] = jj_gen;
1346      jj_consume_token(-1);
1347      throw new ParseException();
1348    }
1349  }
1350
1351  final public void ArithmeticExpression() throws ParseException {
1352 /*@bgen(jjtree) ArithmeticExpression */
1353  ASTArithmeticExpression jjtn000 = new ASTArithmeticExpression(JJTARITHMETICEXPRESSION);
1354  boolean jjtc000 = true;
1355  jjtree.openNodeScope(jjtn000);Token t;
1356    try {
1357      ArithmeticTerm();
1358      label_6:
1359      while (true) {
1360        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1361        case MINUS:
1362        case PLUS:
1363          ;
1364          break;
1365        default:
1366          jj_la1[42] = jj_gen;
1367          break label_6;
1368        }
1369        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1370        case PLUS:
1371          t = jj_consume_token(PLUS);
1372          break;
1373        case MINUS:
1374          t = jj_consume_token(MINUS);
1375          break;
1376        default:
1377          jj_la1[43] = jj_gen;
1378          jj_consume_token(-1);
1379          throw new ParseException();
1380        }
1381                                        jjtn000.ops.add(new Integer JavaDoc(t.kind));
1382        ArithmeticTerm();
1383      }
1384    } catch (Throwable JavaDoc jjte000) {
1385   if (jjtc000) {
1386     jjtree.clearNodeScope(jjtn000);
1387     jjtc000 = false;
1388   } else {
1389     jjtree.popNode();
1390   }
1391   if (jjte000 instanceof RuntimeException JavaDoc) {
1392     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1393   }
1394   if (jjte000 instanceof ParseException) {
1395     {if (true) throw (ParseException)jjte000;}
1396   }
1397   {if (true) throw (Error JavaDoc)jjte000;}
1398    } finally {
1399   if (jjtc000) {
1400     jjtree.closeNodeScope(jjtn000, true);
1401   }
1402    }
1403  }
1404
1405  final public void ArithmeticTerm() throws ParseException {
1406 /*@bgen(jjtree) ArithmeticTerm */
1407  ASTArithmeticTerm jjtn000 = new ASTArithmeticTerm(JJTARITHMETICTERM);
1408  boolean jjtc000 = true;
1409  jjtree.openNodeScope(jjtn000);Token t;
1410    try {
1411      ArithmeticFactor();
1412      label_7:
1413      while (true) {
1414        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1415        case MULT:
1416        case DIV:
1417          ;
1418          break;
1419        default:
1420          jj_la1[44] = jj_gen;
1421          break label_7;
1422        }
1423        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1424        case MULT:
1425          t = jj_consume_token(MULT);
1426          break;
1427        case DIV:
1428          t = jj_consume_token(DIV);
1429          break;
1430        default:
1431          jj_la1[45] = jj_gen;
1432          jj_consume_token(-1);
1433          throw new ParseException();
1434        }
1435                                        jjtn000.ops.add(new Integer JavaDoc(t.kind));
1436        ArithmeticFactor();
1437      }
1438    } catch (Throwable JavaDoc jjte000) {
1439   if (jjtc000) {
1440     jjtree.clearNodeScope(jjtn000);
1441     jjtc000 = false;
1442   } else {
1443     jjtree.popNode();
1444   }
1445   if (jjte000 instanceof RuntimeException JavaDoc) {
1446     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1447   }
1448   if (jjte000 instanceof ParseException) {
1449     {if (true) throw (ParseException)jjte000;}
1450   }
1451   {if (true) throw (Error JavaDoc)jjte000;}
1452    } finally {
1453   if (jjtc000) {
1454     jjtree.closeNodeScope(jjtn000, true);
1455   }
1456    }
1457  }
1458
1459  final public void ArithmeticFactor() throws ParseException {
1460 /*@bgen(jjtree) ArithmeticFactor */
1461 ASTArithmeticFactor jjtn000 = new ASTArithmeticFactor(JJTARITHMETICFACTOR);
1462 boolean jjtc000 = true;
1463 jjtree.openNodeScope(jjtn000);Token t=null;
1464    try {
1465      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1466      case MINUS:
1467      case PLUS:
1468        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1469        case PLUS:
1470          t = jj_consume_token(PLUS);
1471          break;
1472        case MINUS:
1473          t = jj_consume_token(MINUS);
1474          break;
1475        default:
1476          jj_la1[46] = jj_gen;
1477          jj_consume_token(-1);
1478          throw new ParseException();
1479        }
1480        break;
1481      default:
1482        jj_la1[47] = jj_gen;
1483        ;
1484      }
1485      ArithmeticPrimary();
1486     jjtree.closeNodeScope(jjtn000, true);
1487     jjtc000 = false;
1488    jjtn000.ops.add(new Integer JavaDoc((t!=null)?t.kind:EJBQLConstants.PLUS));
1489    } catch (Throwable JavaDoc jjte000) {
1490   if (jjtc000) {
1491     jjtree.clearNodeScope(jjtn000);
1492     jjtc000 = false;
1493   } else {
1494     jjtree.popNode();
1495   }
1496   if (jjte000 instanceof RuntimeException JavaDoc) {
1497     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1498   }
1499   if (jjte000 instanceof ParseException) {
1500     {if (true) throw (ParseException)jjte000;}
1501   }
1502   {if (true) throw (Error JavaDoc)jjte000;}
1503    } finally {
1504   if (jjtc000) {
1505     jjtree.closeNodeScope(jjtn000, true);
1506   }
1507    }
1508  }
1509
1510  final public void ArithmeticPrimary() throws ParseException {
1511    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1512    case IDENTIFIER:
1513      CmpPathExpression();
1514      break;
1515    case INTEGER_LITERAL:
1516    case FLOATING_POINT_LITERAL:
1517      ArithmeticLiteral();
1518      break;
1519    case LPAREN:
1520      jj_consume_token(LPAREN);
1521      ArithmeticExpression();
1522      jj_consume_token(RPAREN);
1523      break;
1524    case input_parameter:
1525      InputParameter();
1526      break;
1527    case ABS:
1528    case LENGTH:
1529    case LOCATE:
1530    case MOD:
1531    case SQRT:
1532      FunctionsReturningNumerics();
1533      break;
1534    default:
1535      jj_la1[48] = jj_gen;
1536      jj_consume_token(-1);
1537      throw new ParseException();
1538    }
1539  }
1540
1541  final public void StringValue() throws ParseException {
1542    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1543    case IDENTIFIER:
1544      CmpPathExpression();
1545      break;
1546    case CONCAT:
1547    case SUBSTRING:
1548      FunctionsReturningStrings();
1549      break;
1550    default:
1551      jj_la1[49] = jj_gen;
1552      jj_consume_token(-1);
1553      throw new ParseException();
1554    }
1555  }
1556
1557  final public void StringExpression() throws ParseException {
1558 /*@bgen(jjtree) StringExpression */
1559  ASTStringExpression jjtn000 = new ASTStringExpression(JJTSTRINGEXPRESSION);
1560  boolean jjtc000 = true;
1561  jjtree.openNodeScope(jjtn000);
1562    try {
1563      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1564      case LPAREN:
1565      case CONCAT:
1566      case SUBSTRING:
1567      case string_literal:
1568      case IDENTIFIER:
1569        StringPrimary();
1570        break;
1571      case input_parameter:
1572        InputParameter();
1573        break;
1574      default:
1575        jj_la1[50] = jj_gen;
1576        jj_consume_token(-1);
1577        throw new ParseException();
1578      }
1579    } catch (Throwable JavaDoc jjte000) {
1580   if (jjtc000) {
1581     jjtree.clearNodeScope(jjtn000);
1582     jjtc000 = false;
1583   } else {
1584     jjtree.popNode();
1585   }
1586   if (jjte000 instanceof RuntimeException JavaDoc) {
1587     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1588   }
1589   if (jjte000 instanceof ParseException) {
1590     {if (true) throw (ParseException)jjte000;}
1591   }
1592   {if (true) throw (Error JavaDoc)jjte000;}
1593    } finally {
1594   if (jjtc000) {
1595     jjtree.closeNodeScope(jjtn000, true);
1596   }
1597    }
1598  }
1599
1600  final public void StringPrimary() throws ParseException {
1601    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1602    case IDENTIFIER:
1603      CmpPathExpression();
1604      break;
1605    case string_literal:
1606      StringLiteral();
1607      break;
1608    case LPAREN:
1609      jj_consume_token(LPAREN);
1610      StringExpression();
1611      jj_consume_token(RPAREN);
1612      break;
1613    case CONCAT:
1614    case SUBSTRING:
1615      FunctionsReturningStrings();
1616      break;
1617    default:
1618      jj_la1[51] = jj_gen;
1619      jj_consume_token(-1);
1620      throw new ParseException();
1621    }
1622  }
1623
1624  final public void DatetimeValue() throws ParseException {
1625    CmpPathExpression();
1626  }
1627
1628  final public void DatetimeExpression() throws ParseException {
1629 /*@bgen(jjtree) DatetimeExpression */
1630  ASTDatetimeExpression jjtn000 = new ASTDatetimeExpression(JJTDATETIMEEXPRESSION);
1631  boolean jjtc000 = true;
1632  jjtree.openNodeScope(jjtn000);
1633    try {
1634      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1635      case IDENTIFIER:
1636        DatetimeValue();
1637        break;
1638      case input_parameter:
1639        InputParameter();
1640        break;
1641      default:
1642        jj_la1[52] = jj_gen;
1643        jj_consume_token(-1);
1644        throw new ParseException();
1645      }
1646    } catch (Throwable JavaDoc jjte000) {
1647   if (jjtc000) {
1648     jjtree.clearNodeScope(jjtn000);
1649     jjtc000 = false;
1650   } else {
1651     jjtree.popNode();
1652   }
1653   if (jjte000 instanceof RuntimeException JavaDoc) {
1654     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1655   }
1656   if (jjte000 instanceof ParseException) {
1657     {if (true) throw (ParseException)jjte000;}
1658   }
1659   {if (true) throw (Error JavaDoc)jjte000;}
1660    } finally {
1661   if (jjtc000) {
1662     jjtree.closeNodeScope(jjtn000, true);
1663   }
1664    }
1665  }
1666
1667  final public void BooleanValue() throws ParseException {
1668    CmpPathExpression();
1669  }
1670
1671  final public void BooleanExpression() throws ParseException {
1672 /*@bgen(jjtree) BooleanExpression */
1673 ASTBooleanExpression jjtn000 = new ASTBooleanExpression(JJTBOOLEANEXPRESSION);
1674 boolean jjtc000 = true;
1675 jjtree.openNodeScope(jjtn000);Token t=null;
1676    try {
1677      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1678      case IDENTIFIER:
1679        CmpPathExpression();
1680        break;
1681      case FALSE:
1682      case TRUE:
1683        BooleanLiteral();
1684        break;
1685      case input_parameter:
1686        InputParameter();
1687     jjtree.closeNodeScope(jjtn000, true);
1688     jjtc000 = false;
1689   if (t!=null) jjtn000.ops.add(new Integer JavaDoc(t.kind));
1690        break;
1691      default:
1692        jj_la1[53] = jj_gen;
1693        jj_consume_token(-1);
1694        throw new ParseException();
1695      }
1696    } catch (Throwable JavaDoc jjte000) {
1697   if (jjtc000) {
1698     jjtree.clearNodeScope(jjtn000);
1699     jjtc000 = false;
1700   } else {
1701     jjtree.popNode();
1702   }
1703   if (jjte000 instanceof RuntimeException JavaDoc) {
1704     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1705   }
1706   if (jjte000 instanceof ParseException) {
1707     {if (true) throw (ParseException)jjte000;}
1708   }
1709   {if (true) throw (Error JavaDoc)jjte000;}
1710    } finally {
1711   if (jjtc000) {
1712     jjtree.closeNodeScope(jjtn000, true);
1713   }
1714    }
1715  }
1716
1717  final public void EntityBeanValue() throws ParseException {
1718    if (jj_2_18(2)) {
1719      SingleValuedCmrPathExpression();
1720    } else if (jj_2_19(2)) {
1721      IdentificationVariable();
1722    } else {
1723      jj_consume_token(-1);
1724      throw new ParseException();
1725    }
1726  }
1727
1728  final public void EntityBeanExpression() throws ParseException {
1729 /*@bgen(jjtree) EntityBeanExpression */
1730  ASTEntityBeanExpression jjtn000 = new ASTEntityBeanExpression(JJTENTITYBEANEXPRESSION);
1731  boolean jjtc000 = true;
1732  jjtree.openNodeScope(jjtn000);
1733    try {
1734      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1735      case IDENTIFIER:
1736        EntityBeanValue();
1737        break;
1738      case input_parameter:
1739        InputParameter();
1740        break;
1741      default:
1742        jj_la1[54] = jj_gen;
1743        jj_consume_token(-1);
1744        throw new ParseException();
1745      }
1746    } catch (Throwable JavaDoc jjte000) {
1747   if (jjtc000) {
1748     jjtree.clearNodeScope(jjtn000);
1749     jjtc000 = false;
1750   } else {
1751     jjtree.popNode();
1752   }
1753   if (jjte000 instanceof RuntimeException JavaDoc) {
1754     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1755   }
1756   if (jjte000 instanceof ParseException) {
1757     {if (true) throw (ParseException)jjte000;}
1758   }
1759   {if (true) throw (Error JavaDoc)jjte000;}
1760    } finally {
1761   if (jjtc000) {
1762     jjtree.closeNodeScope(jjtn000, true);
1763   }
1764    }
1765  }
1766
1767  final public void FunctionsReturningStrings() throws ParseException {
1768 /*@bgen(jjtree) FunctionsReturningStrings */
1769  ASTFunctionsReturningStrings jjtn000 = new ASTFunctionsReturningStrings(JJTFUNCTIONSRETURNINGSTRINGS);
1770  boolean jjtc000 = true;
1771  jjtree.openNodeScope(jjtn000);Token t;
1772    try {
1773      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1774      case CONCAT:
1775        t = jj_consume_token(CONCAT);
1776            jjtn000.ops.add(new Integer JavaDoc(t.kind));
1777        jj_consume_token(LPAREN);
1778        StringExpression();
1779        jj_consume_token(COMMA);
1780        StringExpression();
1781        jj_consume_token(RPAREN);
1782        break;
1783      case SUBSTRING:
1784        t = jj_consume_token(SUBSTRING);
1785                 jjtn000.ops.add(new Integer JavaDoc(t.kind));
1786        jj_consume_token(LPAREN);
1787        StringExpression();
1788        jj_consume_token(COMMA);
1789        ArithmeticExpression();
1790        jj_consume_token(COMMA);
1791        ArithmeticExpression();
1792        jj_consume_token(RPAREN);
1793        break;
1794      default:
1795        jj_la1[55] = jj_gen;
1796        jj_consume_token(-1);
1797        throw new ParseException();
1798      }
1799    } catch (Throwable JavaDoc jjte000) {
1800   if (jjtc000) {
1801     jjtree.clearNodeScope(jjtn000);
1802     jjtc000 = false;
1803   } else {
1804     jjtree.popNode();
1805   }
1806   if (jjte000 instanceof RuntimeException JavaDoc) {
1807     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1808   }
1809   if (jjte000 instanceof ParseException) {
1810     {if (true) throw (ParseException)jjte000;}
1811   }
1812   {if (true) throw (Error JavaDoc)jjte000;}
1813    } finally {
1814   if (jjtc000) {
1815     jjtree.closeNodeScope(jjtn000, true);
1816   }
1817    }
1818  }
1819
1820  final public void FunctionsReturningNumerics() throws ParseException {
1821 /*@bgen(jjtree) FunctionsReturningNumerics */
1822 ASTFunctionsReturningNumerics jjtn000 = new ASTFunctionsReturningNumerics(JJTFUNCTIONSRETURNINGNUMERICS);
1823 boolean jjtc000 = true;
1824 jjtree.openNodeScope(jjtn000);Token t;
1825    try {
1826      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1827      case LENGTH:
1828        t = jj_consume_token(LENGTH);
1829            jjtn000.ops.add(new Integer JavaDoc(t.kind));
1830        jj_consume_token(LPAREN);
1831        StringExpression();
1832        jj_consume_token(RPAREN);
1833        break;
1834      case LOCATE:
1835        t = jj_consume_token(LOCATE);
1836              jjtn000.ops.add(new Integer JavaDoc(t.kind));
1837        jj_consume_token(LPAREN);
1838        StringExpression();
1839        jj_consume_token(COMMA);
1840        StringExpression();
1841        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1842        case COMMA:
1843          jj_consume_token(COMMA);
1844                                                                                                                     jjtn000.third=true;
1845          ArithmeticExpression();
1846          break;
1847        default:
1848          jj_la1[56] = jj_gen;
1849          ;
1850        }
1851        jj_consume_token(RPAREN);
1852        break;
1853      case ABS:
1854        t = jj_consume_token(ABS);
1855           jjtn000.ops.add(new Integer JavaDoc(t.kind));
1856        jj_consume_token(LPAREN);
1857        ArithmeticExpression();
1858        jj_consume_token(RPAREN);
1859        break;
1860      case SQRT:
1861        t = jj_consume_token(SQRT);
1862            jjtn000.ops.add(new Integer JavaDoc(t.kind));
1863        jj_consume_token(LPAREN);
1864        ArithmeticExpression();
1865        jj_consume_token(RPAREN);
1866        break;
1867      case MOD:
1868        t = jj_consume_token(MOD);
1869           jjtn000.ops.add(new Integer JavaDoc(t.kind));
1870        jj_consume_token(LPAREN);
1871        ArithmeticExpression();
1872        jj_consume_token(COMMA);
1873        ArithmeticExpression();
1874        jj_consume_token(RPAREN);
1875        break;
1876      default:
1877        jj_la1[57] = jj_gen;
1878        jj_consume_token(-1);
1879        throw new ParseException();
1880      }
1881    } catch (Throwable JavaDoc jjte000) {
1882   if (jjtc000) {
1883     jjtree.clearNodeScope(jjtn000);
1884     jjtc000 = false;
1885   } else {
1886     jjtree.popNode();
1887   }
1888   if (jjte000 instanceof RuntimeException JavaDoc) {
1889     {if (true) throw (RuntimeException JavaDoc)jjte000;}
1890   }
1891   if (jjte000 instanceof ParseException) {
1892     {if (true) throw (ParseException)jjte000;}
1893   }
1894   {if (true) throw (Error JavaDoc)jjte000;}
1895    } finally {
1896   if (jjtc000) {
1897     jjtree.closeNodeScope(jjtn000, true);
1898   }
1899    }
1900  }
1901
1902  final public void PatternValue() throws ParseException {
1903    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1904    case string_literal:
1905      StringLiteral();
1906      break;
1907    case input_parameter:
1908      InputParameter();
1909      break;
1910    default:
1911      jj_la1[58] = jj_gen;
1912      jj_consume_token(-1);
1913      throw new ParseException();
1914    }
1915  }
1916
1917  final public void EscapeCharacter() throws ParseException {
1918    StringLiteral();
1919  }
1920
1921  final public void AbstractSchemaName() throws ParseException {
1922 /*@bgen(jjtree) AbstractSchemaName */
1923  ASTAbstractSchemaName jjtn000 = new ASTAbstractSchemaName(JJTABSTRACTSCHEMANAME);
1924  boolean jjtc000 = true;
1925  jjtree.openNodeScope(jjtn000);Token t;
1926    try {
1927      t = jj_consume_token(IDENTIFIER);
1928     jjtree.closeNodeScope(jjtn000, true);
1929     jjtc000 = false;
1930      jjtn000.value= t.image;
1931    } finally {
1932   if (jjtc000) {
1933     jjtree.closeNodeScope(jjtn000, true);
1934   }
1935    }
1936  }
1937
1938  final public void IdentificationVariable() throws ParseException {
1939 /*@bgen(jjtree) IdentificationVariable */
1940  ASTIdentificationVariable jjtn000 = new ASTIdentificationVariable(JJTIDENTIFICATIONVARIABLE);
1941  boolean jjtc000 = true;
1942  jjtree.openNodeScope(jjtn000);Token t;
1943    try {
1944      t = jj_consume_token(IDENTIFIER);
1945     jjtree.closeNodeScope(jjtn000, true);
1946     jjtc000 = false;
1947      jjtn000.value= t.image;
1948    } finally {
1949   if (jjtc000) {
1950     jjtree.closeNodeScope(jjtn000, true);
1951   }
1952    }
1953  }
1954
1955  final public void Identifier() throws ParseException {
1956 /*@bgen(jjtree) Identifier */
1957  ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER);
1958  boolean jjtc000 = true;
1959  jjtree.openNodeScope(jjtn000);Token t;
1960    try {
1961      t = jj_consume_token(IDENTIFIER);
1962     jjtree.closeNodeScope(jjtn000, true);
1963     jjtc000 = false;
1964      jjtn000.value= t.image;
1965    } finally {
1966   if (jjtc000) {
1967     jjtree.closeNodeScope(jjtn000, true);
1968   }
1969    }
1970  }
1971
1972  final public void Path() throws ParseException {
1973 /*@bgen(jjtree) Path */
1974 ASTPath jjtn000 = new ASTPath(JJTPATH);
1975 boolean jjtc000 = true;
1976 jjtree.openNodeScope(jjtn000);Token t;
1977    try {
1978      t = jj_consume_token(IDENTIFIER);
1979                jjtn000.value= t.image;
1980      jj_consume_token(DOT);
1981      t = jj_consume_token(IDENTIFIER);
1982                     jjtn000.value = jjtn000.value + "."+t.image;
1983      label_8:
1984      while (true) {
1985        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1986        case DOT:
1987          ;
1988          break;
1989        default:
1990          jj_la1[59] = jj_gen;
1991          break label_8;
1992        }
1993        jj_consume_token(DOT);
1994        t = jj_consume_token(IDENTIFIER);
1995                      jjtn000.value = jjtn000.value + "."+t.image;
1996      }
1997    } finally {
1998   if (jjtc000) {
1999     jjtree.closeNodeScope(jjtn000, true);
2000   }
2001    }
2002  }
2003
2004  final public void Literal() throws ParseException {
2005 /*@bgen(jjtree) Literal */
2006  ASTLiteral jjtn000 = new ASTLiteral(JJTLITERAL);
2007  boolean jjtc000 = true;
2008  jjtree.openNodeScope(jjtn000);
2009    try {
2010      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2011      case string_literal:
2012        StringLiteral();
2013        break;
2014      case INTEGER_LITERAL:
2015      case FLOATING_POINT_LITERAL:
2016        ArithmeticLiteral();
2017        break;
2018      case FALSE:
2019      case TRUE:
2020        BooleanLiteral();
2021        break;
2022      default:
2023        jj_la1[60] = jj_gen;
2024        jj_consume_token(-1);
2025        throw new ParseException();
2026      }
2027    } catch (Throwable JavaDoc jjte000) {
2028   if (jjtc000) {
2029     jjtree.clearNodeScope(jjtn000);
2030     jjtc000 = false;
2031   } else {
2032     jjtree.popNode();
2033   }
2034   if (jjte000 instanceof RuntimeException JavaDoc) {
2035     {if (true) throw (RuntimeException JavaDoc)jjte000;}
2036   }
2037   if (jjte000 instanceof ParseException) {
2038     {if (true) throw (ParseException)jjte000;}
2039   }
2040   {if (true) throw (Error JavaDoc)jjte000;}
2041    } finally {
2042   if (jjtc000) {
2043     jjtree.closeNodeScope(jjtn000, true);
2044   }
2045    }
2046  }
2047
2048  final public void StringLiteral() throws ParseException {
2049 /*@bgen(jjtree) StringLiteral */
2050  ASTStringLiteral jjtn000 = new ASTStringLiteral(JJTSTRINGLITERAL);
2051  boolean jjtc000 = true;
2052  jjtree.openNodeScope(jjtn000);Token t;
2053    try {
2054      t = jj_consume_token(string_literal);
2055     jjtree.closeNodeScope(jjtn000, true);
2056     jjtc000 = false;
2057      jjtn000.value= t.image.substring(1,t.image.length()-1);
2058    } finally {
2059   if (jjtc000) {
2060     jjtree.closeNodeScope(jjtn000, true);
2061   }
2062    }
2063  }
2064
2065  final public void ArithmeticLiteral() throws ParseException {
2066 /*@bgen(jjtree) ArithmeticLiteral */
2067  ASTArithmeticLiteral jjtn000 = new ASTArithmeticLiteral(JJTARITHMETICLITERAL);
2068  boolean jjtc000 = true;
2069  jjtree.openNodeScope(jjtn000);
2070    try {
2071      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2072      case INTEGER_LITERAL:
2073        IntegerLiteral();
2074        break;
2075      case FLOATING_POINT_LITERAL:
2076        FloatingPointLiteral();
2077        break;
2078      default:
2079        jj_la1[61] = jj_gen;
2080        jj_consume_token(-1);
2081        throw new ParseException();
2082      }
2083    } catch (Throwable JavaDoc jjte000) {
2084   if (jjtc000) {
2085     jjtree.clearNodeScope(jjtn000);
2086     jjtc000 = false;
2087   } else {
2088     jjtree.popNode();
2089   }
2090   if (jjte000 instanceof RuntimeException JavaDoc) {
2091     {if (true) throw (RuntimeException JavaDoc)jjte000;}
2092   }
2093   if (jjte000 instanceof ParseException) {
2094     {if (true) throw (ParseException)jjte000;}
2095   }
2096   {if (true) throw (Error JavaDoc)jjte000;}
2097    } finally {
2098   if (jjtc000) {
2099     jjtree.closeNodeScope(jjtn000, true);
2100   }
2101    }
2102  }
2103
2104  final public void IntegerLiteral() throws ParseException {
2105 /*@bgen(jjtree) IntegerLiteral */
2106  ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(JJTINTEGERLITERAL);
2107  boolean jjtc000 = true;
2108  jjtree.openNodeScope(jjtn000);Token t;
2109    try {
2110      t = jj_consume_token(INTEGER_LITERAL);
2111                      jjtree.closeNodeScope(jjtn000, true);
2112                      jjtc000 = false;
2113                     jjtn000.value= new Long JavaDoc(t.image);
2114    } finally {
2115   if (jjtc000) {
2116     jjtree.closeNodeScope(jjtn000, true);
2117   }
2118    }
2119  }
2120
2121  final public void FloatingPointLiteral() throws ParseException {
2122 /*@bgen(jjtree) FloatingPointLiteral */
2123  ASTFloatingPointLiteral jjtn000 = new ASTFloatingPointLiteral(JJTFLOATINGPOINTLITERAL);
2124  boolean jjtc000 = true;
2125  jjtree.openNodeScope(jjtn000);Token t;
2126    try {
2127      t = jj_consume_token(FLOATING_POINT_LITERAL);
2128                             jjtree.closeNodeScope(jjtn000, true);
2129                             jjtc000 = false;
2130                            jjtn000.value= new Double JavaDoc(t.image);
2131    } finally {
2132   if (jjtc000) {
2133     jjtree.closeNodeScope(jjtn000, true);
2134   }
2135    }
2136  }
2137
2138  final public void BooleanLiteral() throws ParseException {
2139 /*@bgen(jjtree) BooleanLiteral */
2140 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(JJTBOOLEANLITERAL);
2141 boolean jjtc000 = true;
2142 jjtree.openNodeScope(jjtn000);Token t;
2143    try {
2144      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2145      case TRUE:
2146        t = jj_consume_token(TRUE);
2147           jjtree.closeNodeScope(jjtn000, true);
2148           jjtc000 = false;
2149          jjtn000.value= Boolean.TRUE;
2150        break;
2151      case FALSE:
2152        t = jj_consume_token(FALSE);
2153             jjtree.closeNodeScope(jjtn000, true);
2154             jjtc000 = false;
2155            jjtn000.value= Boolean.FALSE;
2156        break;
2157      default:
2158        jj_la1[62] = jj_gen;
2159        jj_consume_token(-1);
2160        throw new ParseException();
2161      }
2162    } finally {
2163   if (jjtc000) {
2164     jjtree.closeNodeScope(jjtn000, true);
2165   }
2166    }
2167  }
2168
2169  final public void InputParameter() throws ParseException {
2170 /*@bgen(jjtree) InputParameter */
2171  ASTInputParameter jjtn000 = new ASTInputParameter(JJTINPUTPARAMETER);
2172  boolean jjtc000 = true;
2173  jjtree.openNodeScope(jjtn000);Token t;
2174    try {
2175      t = jj_consume_token(input_parameter);
2176     jjtree.closeNodeScope(jjtn000, true);
2177     jjtc000 = false;
2178      jjtn000.value= new Integer JavaDoc(t.image.substring(1));
2179    } finally {
2180   if (jjtc000) {
2181     jjtree.closeNodeScope(jjtn000, true);
2182   }
2183    }
2184  }
2185
2186  final private boolean jj_2_1(int xla) {
2187    jj_la = xla; jj_lastpos = jj_scanpos = token;
2188    try { return !jj_3_1(); }
2189    catch(LookaheadSuccess ls) { return true; }
2190    finally { jj_save(0, xla); }
2191  }
2192
2193  final private boolean jj_2_2(int xla) {
2194    jj_la = xla; jj_lastpos = jj_scanpos = token;
2195    try { return !jj_3_2(); }
2196    catch(LookaheadSuccess ls) { return true; }
2197    finally { jj_save(1, xla); }
2198  }
2199
2200  final private boolean jj_2_3(int xla) {
2201    jj_la = xla; jj_lastpos = jj_scanpos = token;
2202    try { return !jj_3_3(); }
2203    catch(LookaheadSuccess ls) { return true; }
2204    finally { jj_save(2, xla); }
2205  }
2206
2207  final private boolean jj_2_4(int xla) {
2208    jj_la = xla; jj_lastpos = jj_scanpos = token;
2209    try { return !jj_3_4(); }
2210    catch(LookaheadSuccess ls) { return true; }
2211    finally { jj_save(3, xla); }
2212  }
2213
2214  final private boolean jj_2_5(int xla) {
2215    jj_la = xla; jj_lastpos = jj_scanpos = token;
2216    try { return !jj_3_5(); }
2217    catch(LookaheadSuccess ls) { return true; }
2218    finally { jj_save(4, xla); }
2219  }
2220
2221  final private boolean jj_2_6(int xla) {
2222    jj_la = xla; jj_lastpos = jj_scanpos = token;
2223    try { return !jj_3_6(); }
2224    catch(LookaheadSuccess ls) { return true; }
2225    finally { jj_save(5, xla); }
2226  }
2227
2228  final private boolean jj_2_7(int xla) {
2229    jj_la = xla; jj_lastpos = jj_scanpos = token;
2230    try { return !jj_3_7(); }
2231    catch(LookaheadSuccess ls) { return true; }
2232    finally { jj_save(6, xla); }
2233  }
2234
2235  final private boolean jj_2_8(int xla) {
2236    jj_la = xla; jj_lastpos = jj_scanpos = token;
2237    try { return !jj_3_8(); }
2238    catch(LookaheadSuccess ls) { return true; }
2239    finally { jj_save(7, xla); }
2240  }
2241
2242  final private boolean jj_2_9(int xla) {
2243    jj_la = xla; jj_lastpos = jj_scanpos = token;
2244    try { return !jj_3_9(); }
2245    catch(LookaheadSuccess ls) { return true; }
2246    finally { jj_save(8, xla); }
2247  }
2248
2249  final private boolean jj_2_10(int xla) {
2250    jj_la = xla; jj_lastpos = jj_scanpos = token;
2251    try { return !jj_3_10(); }
2252    catch(LookaheadSuccess ls) { return true; }
2253    finally { jj_save(9, xla); }
2254  }
2255
2256  final private boolean jj_2_11(int xla) {
2257    jj_la = xla; jj_lastpos = jj_scanpos = token;
2258    try { return !jj_3_11(); }
2259    catch(LookaheadSuccess ls) { return true; }
2260    finally { jj_save(10, xla); }
2261  }
2262
2263  final private boolean jj_2_12(int xla) {
2264    jj_la = xla; jj_lastpos = jj_scanpos = token;
2265    try { return !jj_3_12(); }
2266    catch(LookaheadSuccess ls) { return true; }
2267    finally { jj_save(11, xla); }
2268  }
2269
2270  final private boolean jj_2_13(int xla) {
2271    jj_la = xla; jj_lastpos = jj_scanpos = token;
2272    try { return !jj_3_13(); }
2273    catch(LookaheadSuccess ls) { return true; }
2274    finally { jj_save(12, xla); }
2275  }
2276
2277  final private boolean jj_2_14(int xla) {
2278    jj_la = xla; jj_lastpos = jj_scanpos = token;
2279    try { return !jj_3_14(); }
2280    catch(LookaheadSuccess ls) { return true; }
2281    finally { jj_save(13, xla); }
2282  }
2283
2284  final private boolean jj_2_15(int xla) {
2285    jj_la = xla; jj_lastpos = jj_scanpos = token;
2286    try { return !jj_3_15(); }
2287    catch(LookaheadSuccess ls) { return true; }
2288    finally { jj_save(14, xla); }
2289  }
2290
2291  final private boolean jj_2_16(int xla) {
2292    jj_la = xla; jj_lastpos = jj_scanpos = token;
2293    try { return !jj_3_16(); }
2294    catch(LookaheadSuccess ls) { return true; }
2295    finally { jj_save(15, xla); }
2296  }
2297
2298  final private boolean jj_2_17(int xla) {
2299    jj_la = xla; jj_lastpos = jj_scanpos = token;
2300    try { return !jj_3_17(); }
2301    catch(LookaheadSuccess ls) { return true; }
2302    finally { jj_save(16, xla); }
2303  }
2304
2305  final private boolean jj_2_18(int xla) {
2306    jj_la = xla; jj_lastpos = jj_scanpos = token;
2307    try { return !jj_3_18(); }
2308    catch(LookaheadSuccess ls) { return true; }
2309    finally { jj_save(17, xla); }
2310  }
2311
2312  final private boolean jj_2_19(int xla) {
2313    jj_la = xla; jj_lastpos = jj_scanpos = token;
2314    try { return !jj_3_19(); }
2315    catch(LookaheadSuccess ls) { return true; }
2316    finally { jj_save(18, xla); }
2317  }
2318
2319  final private boolean jj_3R_120() {
2320    if (jj_scan_token(LPAREN)) return true;
2321    if (jj_3R_30()) return true;
2322    if (jj_scan_token(RPAREN)) return true;
2323    return false;
2324  }
2325
2326  final private boolean jj_3R_102() {
2327    if (jj_3R_95()) return true;
2328    return false;
2329  }
2330
2331  final private boolean jj_3R_23() {
2332    if (jj_3R_47()) return true;
2333    return false;
2334  }
2335
2336  final private boolean jj_3_1() {
2337    if (jj_3R_9()) return true;
2338    return false;
2339  }
2340
2341  final private boolean jj_3R_69() {
2342    if (jj_3R_25()) return true;
2343    return false;
2344  }
2345
2346  final private boolean jj_3R_26() {
2347    Token xsp;
2348    xsp = jj_scanpos;
2349    if (jj_3R_69()) {
2350    jj_scanpos = xsp;
2351    if (jj_3R_70()) return true;
2352    }
2353    return false;
2354  }
2355
2356  final private boolean jj_3R_65() {
2357    if (jj_3R_84()) return true;
2358    return false;
2359  }
2360
2361  final private boolean jj_3R_63() {
2362    if (jj_3R_87()) return true;
2363    return false;
2364  }
2365
2366  final private boolean jj_3R_25() {
2367    if (jj_3R_47()) return true;
2368    return false;
2369  }
2370
2371  final private boolean jj_3R_122() {
2372    if (jj_3R_90()) return true;
2373    return false;
2374  }
2375
2376  final private boolean jj_3R_119() {
2377    if (jj_3R_116()) return true;
2378    return false;
2379  }
2380
2381  final private boolean jj_3R_101() {
2382    if (jj_3R_47()) return true;
2383    return false;
2384  }
2385
2386  final private boolean jj_3R_88() {
2387    Token xsp;
2388    xsp = jj_scanpos;
2389    if (jj_3R_101()) {
2390    jj_scanpos = xsp;
2391    if (jj_3R_102()) {
2392    jj_scanpos = xsp;
2393    if (jj_3R_103()) {
2394    jj_scanpos = xsp;
2395    if (jj_3R_104()) return true;
2396    }
2397    }
2398    }
2399    return false;
2400  }
2401
2402  final private boolean jj_3R_64() {
2403    if (jj_3R_88()) return true;
2404    return false;
2405  }
2406
2407  final private boolean jj_3R_22() {
2408    Token xsp;
2409    xsp = jj_scanpos;
2410    if (jj_3R_64()) {
2411    jj_scanpos = xsp;
2412    if (jj_3R_65()) return true;
2413    }
2414    return false;
2415  }
2416
2417  final private boolean jj_3R_62() {
2418    if (jj_3R_47()) return true;
2419    return false;
2420  }
2421
2422  final private boolean jj_3R_21() {
2423    Token xsp;
2424    xsp = jj_scanpos;
2425    if (jj_3R_62()) {
2426    jj_scanpos = xsp;
2427    if (jj_3R_63()) return true;
2428    }
2429    return false;
2430  }
2431
2432  final private boolean jj_3R_92() {
2433    Token xsp;
2434    xsp = jj_scanpos;
2435    if (jj_scan_token(6)) {
2436    jj_scanpos = xsp;
2437    if (jj_scan_token(11)) return true;
2438    }
2439    if (jj_3R_91()) return true;
2440    return false;
2441  }
2442
2443  final private boolean jj_3R_121() {
2444    if (jj_3R_84()) return true;
2445    return false;
2446  }
2447
2448  final private boolean jj_3R_118() {
2449    if (jj_3R_47()) return true;
2450    return false;
2451  }
2452
2453  final private boolean jj_3R_113() {
2454    Token xsp;
2455    xsp = jj_scanpos;
2456    if (jj_3R_118()) {
2457    jj_scanpos = xsp;
2458    if (jj_3R_119()) {
2459    jj_scanpos = xsp;
2460    if (jj_3R_120()) {
2461    jj_scanpos = xsp;
2462    if (jj_3R_121()) {
2463    jj_scanpos = xsp;
2464    if (jj_3R_122()) return true;
2465    }
2466    }
2467    }
2468    }
2469    return false;
2470  }
2471
2472  final private boolean jj_3R_76() {
2473    Token xsp;
2474    xsp = jj_scanpos;
2475    if (jj_scan_token(8)) {
2476    jj_scanpos = xsp;
2477    if (jj_scan_token(5)) return true;
2478    }
2479    if (jj_3R_75()) return true;
2480    return false;
2481  }
2482
2483  final private boolean jj_3R_74() {
2484    if (jj_3R_90()) return true;
2485    return false;
2486  }
2487
2488  final private boolean jj_3R_117() {
2489    if (jj_scan_token(COMMA)) return true;
2490    if (jj_3R_30()) return true;
2491    return false;
2492  }
2493
2494  final private boolean jj_3R_112() {
2495    Token xsp;
2496    xsp = jj_scanpos;
2497    if (jj_scan_token(8)) {
2498    jj_scanpos = xsp;
2499    if (jj_scan_token(5)) return true;
2500    }
2501    return false;
2502  }
2503
2504  final private boolean jj_3R_91() {
2505    Token xsp;
2506    xsp = jj_scanpos;
2507    if (jj_3R_112()) jj_scanpos = xsp;
2508    if (jj_3R_113()) return true;
2509    return false;
2510  }
2511
2512  final private boolean jj_3R_58() {
2513    if (jj_3R_31()) return true;
2514    return false;
2515  }
2516
2517  final private boolean jj_3R_84() {
2518    if (jj_scan_token(input_parameter)) return true;
2519    return false;
2520  }
2521
2522  final private boolean jj_3R_98() {
2523    if (jj_3R_89()) return true;
2524    return false;
2525  }
2526
2527  final private boolean jj_3R_75() {
2528    if (jj_3R_91()) return true;
2529    Token xsp;
2530    while (true) {
2531      xsp = jj_scanpos;
2532      if (jj_3R_92()) { jj_scanpos = xsp; break; }
2533    }
2534    return false;
2535  }
2536
2537  final private boolean jj_3R_19() {
2538    if (jj_3R_31()) return true;
2539    return false;
2540  }
2541
2542  final private boolean jj_3R_106() {
2543    if (jj_scan_token(FALSE)) return true;
2544    return false;
2545  }
2546
2547  final private boolean jj_3R_124() {
2548    if (jj_3R_126()) return true;
2549    return false;
2550  }
2551
2552  final private boolean jj_3R_105() {
2553    if (jj_scan_token(TRUE)) return true;
2554    return false;
2555  }
2556
2557  final private boolean jj_3R_89() {
2558    Token xsp;
2559    xsp = jj_scanpos;
2560    if (jj_3R_105()) {
2561    jj_scanpos = xsp;
2562    if (jj_3R_106()) return true;
2563    }
2564    return false;
2565  }
2566
2567  final private boolean jj_3R_30() {
2568    if (jj_3R_75()) return true;
2569    Token xsp;
2570    while (true) {
2571      xsp = jj_scanpos;
2572      if (jj_3R_76()) { jj_scanpos = xsp; break; }
2573    }
2574    return false;
2575  }
2576
2577  final private boolean jj_3R_47() {
2578    if (jj_3R_31()) return true;
2579    return false;
2580  }
2581
2582  final private boolean jj_3_17() {
2583    if (jj_3R_29()) return true;
2584    Token xsp;
2585    xsp = jj_scanpos;
2586    if (jj_scan_token(9)) {
2587    jj_scanpos = xsp;
2588    if (jj_scan_token(13)) {
2589    jj_scanpos = xsp;
2590    if (jj_scan_token(7)) {
2591    jj_scanpos = xsp;
2592    if (jj_scan_token(18)) {
2593    jj_scanpos = xsp;
2594    if (jj_scan_token(10)) {
2595    jj_scanpos = xsp;
2596    if (jj_scan_token(16)) return true;
2597    }
2598    }
2599    }
2600    }
2601    }
2602    if (jj_3R_30()) return true;
2603    return false;
2604  }
2605
2606  final private boolean jj_3_16() {
2607    if (jj_3R_27()) return true;
2608    Token xsp;
2609    xsp = jj_scanpos;
2610    if (jj_scan_token(9)) {
2611    jj_scanpos = xsp;
2612    if (jj_scan_token(16)) return true;
2613    }
2614    if (jj_3R_28()) return true;
2615    return false;
2616  }
2617
2618  final private boolean jj_3R_126() {
2619    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
2620    return false;
2621  }
2622
2623  final private boolean jj_3R_73() {
2624    if (jj_3R_47()) return true;
2625    return false;
2626  }
2627
2628  final private boolean jj_3R_29() {
2629    Token xsp;
2630    xsp = jj_scanpos;
2631    if (jj_3R_73()) {
2632    jj_scanpos = xsp;
2633    if (jj_3R_74()) return true;
2634    }
2635    return false;
2636  }
2637
2638  final private boolean jj_3R_9() {
2639    if (jj_3R_31()) return true;
2640    return false;
2641  }
2642
2643  final private boolean jj_3_15() {
2644    if (jj_3R_25()) return true;
2645    Token xsp;
2646    xsp = jj_scanpos;
2647    if (jj_scan_token(9)) {
2648    jj_scanpos = xsp;
2649    if (jj_scan_token(13)) {
2650    jj_scanpos = xsp;
2651    if (jj_scan_token(7)) {
2652    jj_scanpos = xsp;
2653    if (jj_scan_token(18)) {
2654    jj_scanpos = xsp;
2655    if (jj_scan_token(10)) {
2656    jj_scanpos = xsp;
2657    if (jj_scan_token(16)) return true;
2658    }
2659    }
2660    }
2661    }
2662    }
2663    if (jj_3R_26()) return true;
2664    return false;
2665  }
2666
2667  final private boolean jj_3_14() {
2668    if (jj_3R_23()) return true;
2669    Token xsp;
2670    xsp = jj_scanpos;
2671    if (jj_scan_token(9)) {
2672    jj_scanpos = xsp;
2673    if (jj_scan_token(16)) return true;
2674    }
2675    if (jj_3R_24()) return true;
2676    return false;
2677  }
2678
2679  final private boolean jj_3R_125() {
2680    if (jj_scan_token(INTEGER_LITERAL)) return true;
2681    return false;
2682  }
2683
2684  final private boolean jj_3_13() {
2685    if (jj_3R_21()) return true;
2686    Token xsp;
2687    xsp = jj_scanpos;
2688    if (jj_scan_token(9)) {
2689    jj_scanpos = xsp;
2690    if (jj_scan_token(13)) {
2691    jj_scanpos = xsp;
2692    if (jj_scan_token(7)) {
2693    jj_scanpos = xsp;
2694    if (jj_scan_token(18)) {
2695    jj_scanpos = xsp;
2696    if (jj_scan_token(10)) {
2697    jj_scanpos = xsp;
2698    if (jj_scan_token(16)) return true;
2699    }
2700    }
2701    }
2702    }
2703    }
2704    if (jj_3R_22()) return true;
2705    return false;
2706  }
2707
2708  final private boolean jj_3R_45() {
2709    if (jj_3R_29()) return true;
2710    Token xsp;
2711    xsp = jj_scanpos;
2712    if (jj_scan_token(9)) {
2713    jj_scanpos = xsp;
2714    if (jj_scan_token(13)) {
2715    jj_scanpos = xsp;
2716    if (jj_scan_token(7)) {
2717    jj_scanpos = xsp;
2718    if (jj_scan_token(18)) {
2719    jj_scanpos = xsp;
2720    if (jj_scan_token(10)) {
2721    jj_scanpos = xsp;
2722    if (jj_scan_token(16)) return true;
2723    }
2724    }
2725    }
2726    }
2727    }
2728    if (jj_3R_30()) return true;
2729    return false;
2730  }
2731
2732  final private boolean jj_3R_56() {
2733    if (jj_3R_84()) return true;
2734    return false;
2735  }
2736
2737  final private boolean jj_3R_97() {
2738    if (jj_3R_116()) return true;
2739    return false;
2740  }
2741
2742  final private boolean jj_3R_44() {
2743    if (jj_3R_27()) return true;
2744    Token xsp;
2745    xsp = jj_scanpos;
2746    if (jj_scan_token(9)) {
2747    jj_scanpos = xsp;
2748    if (jj_scan_token(16)) return true;
2749    }
2750    if (jj_3R_28()) return true;
2751    return false;
2752  }
2753
2754  final private boolean jj_3R_43() {
2755    if (jj_3R_25()) return true;
2756    Token xsp;
2757    xsp = jj_scanpos;
2758    if (jj_scan_token(9)) {
2759    jj_scanpos = xsp;
2760    if (jj_scan_token(13)) {
2761    jj_scanpos = xsp;
2762    if (jj_scan_token(7)) {
2763    jj_scanpos = xsp;
2764    if (jj_scan_token(18)) {
2765    jj_scanpos = xsp;
2766    if (jj_scan_token(10)) {
2767    jj_scanpos = xsp;
2768    if (jj_scan_token(16)) return true;
2769    }
2770    }
2771    }
2772    }
2773    }
2774    if (jj_3R_26()) return true;
2775    return false;
2776  }
2777
2778  final private boolean jj_3R_123() {
2779    if (jj_3R_125()) return true;
2780    return false;
2781  }
2782
2783  final private boolean jj_3R_116() {
2784    Token xsp;
2785    xsp = jj_scanpos;
2786    if (jj_3R_123()) {
2787    jj_scanpos = xsp;
2788    if (jj_3R_124()) return true;
2789    }
2790    return false;
2791  }
2792
2793  final private boolean jj_3R_42() {
2794    if (jj_3R_23()) return true;
2795    Token xsp;
2796    xsp = jj_scanpos;
2797    if (jj_scan_token(9)) {
2798    jj_scanpos = xsp;
2799    if (jj_scan_token(16)) return true;
2800    }
2801    if (jj_3R_24()) return true;
2802    return false;
2803  }
2804
2805  final private boolean jj_3R_12() {
2806    Token xsp;
2807    xsp = jj_scanpos;
2808    if (jj_3R_41()) {
2809    jj_scanpos = xsp;
2810    if (jj_3R_42()) {
2811    jj_scanpos = xsp;
2812    if (jj_3R_43()) {
2813    jj_scanpos = xsp;
2814    if (jj_3R_44()) {
2815    jj_scanpos = xsp;
2816    if (jj_3R_45()) return true;
2817    }
2818    }
2819    }
2820    }
2821    return false;
2822  }
2823
2824  final private boolean jj_3R_41() {
2825    if (jj_3R_21()) return true;
2826    Token xsp;
2827    xsp = jj_scanpos;
2828    if (jj_scan_token(9)) {
2829    jj_scanpos = xsp;
2830    if (jj_scan_token(13)) {
2831    jj_scanpos = xsp;
2832    if (jj_scan_token(7)) {
2833    jj_scanpos = xsp;
2834    if (jj_scan_token(18)) {
2835    jj_scanpos = xsp;
2836    if (jj_scan_token(10)) {
2837    jj_scanpos = xsp;
2838    if (jj_scan_token(16)) return true;
2839    }
2840    }
2841    }
2842    }
2843    }
2844    if (jj_3R_22()) return true;
2845    return false;
2846  }
2847
2848  final private boolean jj_3R_61() {
2849    if (jj_scan_token(NOT)) return true;
2850    return false;
2851  }
2852
2853  final private boolean jj_3R_50() {
2854    if (jj_scan_token(ESCAPE)) return true;
2855    if (jj_3R_82()) return true;
2856    return false;
2857  }
2858
2859  final private boolean jj_3R_95() {
2860    if (jj_scan_token(string_literal)) return true;
2861    return false;
2862  }
2863
2864  final private boolean jj_3R_86() {
2865    if (jj_3R_84()) return true;
2866    return false;
2867  }
2868
2869  final private boolean jj_3R_60() {
2870    if (jj_3R_84()) return true;
2871    return false;
2872  }
2873
2874  final private boolean jj_3_12() {
2875    if (jj_3R_20()) return true;
2876    return false;
2877  }
2878
2879  final private boolean jj_3R_53() {
2880    if (jj_3R_84()) return true;
2881    return false;
2882  }
2883
2884  final private boolean jj_3_11() {
2885    if (jj_3R_19()) return true;
2886    return false;
2887  }
2888
2889  final private boolean jj_3R_48() {
2890    if (jj_scan_token(NOT)) return true;
2891    return false;
2892  }
2893
2894  final private boolean jj_3R_18() {
2895    Token xsp;
2896    xsp = jj_scanpos;
2897    if (jj_3_11()) {
2898    jj_scanpos = xsp;
2899    if (jj_3_12()) {
2900    jj_scanpos = xsp;
2901    if (jj_3R_60()) return true;
2902    }
2903    }
2904    xsp = jj_scanpos;
2905    if (jj_3R_61()) jj_scanpos = xsp;
2906    if (jj_scan_token(MEMBER)) return true;
2907    xsp = jj_scanpos;
2908    if (jj_scan_token(45)) jj_scanpos = xsp;
2909    if (jj_3R_58()) return true;
2910    return false;
2911  }
2912
2913  final private boolean jj_3R_96() {
2914    if (jj_3R_95()) return true;
2915    return false;
2916  }
2917
2918  final private boolean jj_3R_83() {
2919    Token xsp;
2920    xsp = jj_scanpos;
2921    if (jj_3R_96()) {
2922    jj_scanpos = xsp;
2923    if (jj_3R_97()) {
2924    jj_scanpos = xsp;
2925    if (jj_3R_98()) return true;
2926    }
2927    }
2928    return false;
2929  }
2930
2931  final private boolean jj_3R_59() {
2932    if (jj_scan_token(NOT)) return true;
2933    return false;
2934  }
2935
2936  final private boolean jj_3R_77() {
2937    if (jj_scan_token(DOT)) return true;
2938    if (jj_scan_token(IDENTIFIER)) return true;
2939    return false;
2940  }
2941
2942  final private boolean jj_3R_17() {
2943    if (jj_3R_58()) return true;
2944    if (jj_scan_token(IS)) return true;
2945    Token xsp;
2946    xsp = jj_scanpos;
2947    if (jj_3R_59()) jj_scanpos = xsp;
2948    if (jj_scan_token(EMPTY)) return true;
2949    return false;
2950  }
2951
2952  final private boolean jj_3R_51() {
2953    if (jj_scan_token(NOT)) return true;
2954    return false;
2955  }
2956
2957  final private boolean jj_3R_85() {
2958    if (jj_3R_83()) return true;
2959    return false;
2960  }
2961
2962  final private boolean jj_3R_57() {
2963    if (jj_scan_token(NOT)) return true;
2964    return false;
2965  }
2966
2967  final private boolean jj_3R_31() {
2968    if (jj_scan_token(IDENTIFIER)) return true;
2969    if (jj_scan_token(DOT)) return true;
2970    if (jj_scan_token(IDENTIFIER)) return true;
2971    Token xsp;
2972    while (true) {
2973      xsp = jj_scanpos;
2974      if (jj_3R_77()) { jj_scanpos = xsp; break; }
2975    }
2976    return false;
2977  }
2978
2979  final private boolean jj_3R_52() {
2980    if (jj_3R_83()) return true;
2981    return false;
2982  }
2983
2984  final private boolean jj_3R_46() {
2985    if (jj_scan_token(NOT)) return true;
2986    return false;
2987  }
2988
2989  final private boolean jj_3R_55() {
2990    if (jj_3R_9()) return true;
2991    return false;
2992  }
2993
2994  final private boolean jj_3R_16() {
2995    Token xsp;
2996    xsp = jj_scanpos;
2997    if (jj_3R_55()) {
2998    jj_scanpos = xsp;
2999    if (jj_3R_56()) return true;
3000    }
3001    if (jj_scan_token(IS)) return true;
3002    xsp = jj_scanpos;
3003    if (jj_3R_57()) jj_scanpos = xsp;
3004    if (jj_scan_token(NULL)) return true;
3005    return false;
3006  }
3007
3008  final private boolean jj_3R_54() {
3009    if (jj_scan_token(COMMA)) return true;
3010    Token xsp;
3011    xsp = jj_scanpos;
3012    if (jj_3R_85()) {
3013    jj_scanpos = xsp;
3014    if (jj_3R_86()) return true;
3015    }
3016    return false;
3017  }
3018
3019  final private boolean jj_3R_14() {
3020    if (jj_3R_47()) return true;
3021    Token xsp;
3022    xsp = jj_scanpos;
3023    if (jj_3R_48()) jj_scanpos = xsp;
3024    if (jj_scan_token(LIKE)) return true;
3025    if (jj_3R_49()) return true;
3026    xsp = jj_scanpos;
3027    if (jj_3R_50()) jj_scanpos = xsp;
3028    return false;
3029  }
3030
3031  final private boolean jj_3R_20() {
3032    if (jj_scan_token(IDENTIFIER)) return true;
3033    return false;
3034  }
3035
3036  final private boolean jj_3R_15() {
3037    if (jj_3R_47()) return true;
3038    Token xsp;
3039    xsp = jj_scanpos;
3040    if (jj_3R_51()) jj_scanpos = xsp;
3041    if (jj_scan_token(IN)) return true;
3042    if (jj_scan_token(LPAREN)) return true;
3043    xsp = jj_scanpos;
3044    if (jj_3R_52()) {
3045    jj_scanpos = xsp;
3046    if (jj_3R_53()) return true;
3047    }
3048    while (true) {
3049      xsp = jj_scanpos;
3050      if (jj_3R_54()) { jj_scanpos = xsp; break; }
3051    }
3052    if (jj_scan_token(RPAREN)) return true;
3053    return false;
3054  }
3055
3056  final private boolean jj_3_10() {
3057    if (jj_3R_18()) return true;
3058    return false;
3059  }
3060
3061  final private boolean jj_3R_81() {
3062    if (jj_3R_84()) return true;
3063    return false;
3064  }
3065
3066  final private boolean jj_3_9() {
3067    if (jj_3R_17()) return true;
3068    return false;
3069  }
3070
3071  final private boolean jj_3_8() {
3072    if (jj_3R_16()) return true;
3073    return false;
3074  }
3075
3076  final private boolean jj_3_7() {
3077    if (jj_3R_15()) return true;
3078    return false;
3079  }
3080
3081  final private boolean jj_3_6() {
3082    if (jj_3R_14()) return true;
3083    return false;
3084  }
3085
3086  final private boolean jj_3_19() {
3087    if (jj_3R_20()) return true;
3088    return false;
3089  }
3090
3091  final private boolean jj_3R_13() {
3092    if (jj_3R_30()) return true;
3093    Token xsp;
3094    xsp = jj_scanpos;
3095    if (jj_3R_46()) jj_scanpos = xsp;
3096    if (jj_scan_token(BETWEEN)) return true;
3097    if (jj_3R_30()) return true;
3098    if (jj_scan_token(AND)) return true;
3099    if (jj_3R_30()) return true;
3100    return false;
3101  }
3102
3103  final private boolean jj_3_5() {
3104    if (jj_3R_13()) return true;
3105    return false;
3106  }
3107
3108  final private boolean jj_3R_104() {
3109    if (jj_3R_87()) return true;
3110    return false;
3111  }
3112
3113  final private boolean jj_3_4() {
3114    if (jj_3R_12()) return true;
3115    return false;
3116  }
3117
3118  final private boolean jj_3R_38() {
3119    if (jj_3R_18()) return true;
3120    return false;
3121  }
3122
3123  final private boolean jj_3R_37() {
3124    if (jj_3R_17()) return true;
3125    return false;
3126  }
3127
3128  final private boolean jj_3R_36() {
3129    if (jj_3R_16()) return true;
3130    return false;
3131  }
3132
3133  final private boolean jj_3R_82() {
3134    if (jj_3R_95()) return true;
3135    return false;
3136  }
3137
3138  final private boolean jj_3_3() {
3139    if (jj_scan_token(LPAREN)) return true;
3140    if (jj_3R_11()) return true;
3141    if (jj_scan_token(RPAREN)) return true;
3142    return false;
3143  }
3144
3145  final private boolean jj_3R_35() {
3146    if (jj_3R_15()) return true;
3147    return false;
3148  }
3149
3150  final private boolean jj_3R_34() {
3151    if (jj_3R_14()) return true;
3152    return false;
3153  }
3154
3155  final private boolean jj_3R_33() {
3156    if (jj_3R_13()) return true;
3157    return false;
3158  }
3159
3160  final private boolean jj_3_2() {
3161    if (jj_3R_10()) return true;
3162    return false;
3163  }
3164
3165  final private boolean jj_3R_79() {
3166    if (jj_scan_token(AND)) return true;
3167    if (jj_3R_78()) return true;
3168    return false;
3169  }
3170
3171  final private boolean jj_3R_10() {
3172    Token xsp;
3173    xsp = jj_scanpos;
3174    if (jj_3R_32()) {
3175    jj_scanpos = xsp;
3176    if (jj_3R_33()) {
3177    jj_scanpos = xsp;
3178    if (jj_3R_34()) {
3179    jj_scanpos = xsp;
3180    if (jj_3R_35()) {
3181    jj_scanpos = xsp;
3182    if (jj_3R_36()) {
3183    jj_scanpos = xsp;
3184    if (jj_3R_37()) {
3185    jj_scanpos = xsp;
3186    if (jj_3R_38()) return true;
3187    }
3188    }
3189    }
3190    }
3191    }
3192    }
3193    return false;
3194  }
3195
3196  final private boolean jj_3R_32() {
3197    if (jj_3R_12()) return true;
3198    return false;
3199  }
3200
3201  final private boolean jj_3R_80() {
3202    if (jj_3R_95()) return true;
3203    return false;
3204  }
3205
3206  final private boolean jj_3R_68() {
3207    if (jj_3R_84()) return true;
3208    return false;
3209  }
3210
3211  final private boolean jj_3R_49() {
3212    Token xsp;
3213    xsp = jj_scanpos;
3214    if (jj_3R_80()) {
3215    jj_scanpos = xsp;
3216    if (jj_3R_81()) return true;
3217    }
3218    return false;
3219  }
3220
3221  final private boolean jj_3R_115() {
3222    if (jj_scan_token(LPAREN)) return true;
3223    if (jj_3R_11()) return true;
3224    if (jj_scan_token(RPAREN)) return true;
3225    return false;
3226  }
3227
3228  final private boolean jj_3R_111() {
3229    if (jj_scan_token(MOD)) return true;
3230    if (jj_scan_token(LPAREN)) return true;
3231    if (jj_3R_30()) return true;
3232    if (jj_scan_token(COMMA)) return true;
3233    if (jj_3R_30()) return true;
3234    if (jj_scan_token(RPAREN)) return true;
3235    return false;
3236  }
3237
3238  final private boolean jj_3R_110() {
3239    if (jj_scan_token(SQRT)) return true;
3240    if (jj_scan_token(LPAREN)) return true;
3241    if (jj_3R_30()) return true;
3242    if (jj_scan_token(RPAREN)) return true;
3243    return false;
3244  }
3245
3246  final private boolean jj_3R_72() {
3247    if (jj_3R_84()) return true;
3248    return false;
3249  }
3250
3251  final private boolean jj_3R_109() {
3252    if (jj_scan_token(ABS)) return true;
3253    if (jj_scan_token(LPAREN)) return true;
3254    if (jj_3R_30()) return true;
3255    if (jj_scan_token(RPAREN)) return true;
3256    return false;
3257  }
3258
3259  final private boolean jj_3R_108() {
3260    if (jj_scan_token(LOCATE)) return true;
3261    if (jj_scan_token(LPAREN)) return true;
3262    if (jj_3R_22()) return true;
3263    if (jj_scan_token(COMMA)) return true;
3264    if (jj_3R_22()) return true;
3265    Token xsp;
3266    xsp = jj_scanpos;
3267    if (jj_3R_117()) jj_scanpos = xsp;
3268    if (jj_scan_token(RPAREN)) return true;
3269    return false;
3270  }
3271
3272  final private boolean jj_3R_40() {
3273    if (jj_scan_token(OR)) return true;
3274    if (jj_3R_39()) return true;
3275    return false;
3276  }
3277
3278  final private boolean jj_3R_114() {
3279    if (jj_3R_10()) return true;
3280    return false;
3281  }
3282
3283  final private boolean jj_3R_94() {
3284    Token xsp;
3285    xsp = jj_scanpos;
3286    if (jj_3R_114()) {
3287    jj_scanpos = xsp;
3288    if (jj_3R_115()) return true;
3289    }
3290    return false;
3291  }
3292
3293  final private boolean jj_3R_107() {
3294    if (jj_scan_token(LENGTH)) return true;
3295    if (jj_scan_token(LPAREN)) return true;
3296    if (jj_3R_22()) return true;
3297    if (jj_scan_token(RPAREN)) return true;
3298    return false;
3299  }
3300
3301  final private boolean jj_3R_90() {
3302    Token xsp;
3303    xsp = jj_scanpos;
3304    if (jj_3R_107()) {
3305    jj_scanpos = xsp;
3306    if (jj_3R_108()) {
3307    jj_scanpos = xsp;
3308    if (jj_3R_109()) {
3309    jj_scanpos = xsp;
3310    if (jj_3R_110()) {
3311    jj_scanpos = xsp;
3312    if (jj_3R_111()) return true;
3313    }
3314    }
3315    }
3316    }
3317    return false;
3318  }
3319
3320  final private boolean jj_3R_93() {
3321    if (jj_scan_token(NOT)) return true;
3322    return false;
3323  }
3324
3325  final private boolean jj_3R_78() {
3326    Token xsp;
3327    xsp = jj_scanpos;
3328    if (jj_3R_93()) jj_scanpos = xsp;
3329    if (jj_3R_94()) return true;
3330    return false;
3331  }
3332
3333  final private boolean jj_3R_100() {
3334    if (jj_scan_token(SUBSTRING)) return true;
3335    if (jj_scan_token(LPAREN)) return true;
3336    if (jj_3R_22()) return true;
3337    if (jj_scan_token(COMMA)) return true;
3338    if (jj_3R_30()) return true;
3339    if (jj_scan_token(COMMA)) return true;
3340    if (jj_3R_30()) return true;
3341    if (jj_scan_token(RPAREN)) return true;
3342    return false;
3343  }
3344
3345  final private boolean jj_3R_99() {
3346    if (jj_scan_token(CONCAT)) return true;
3347    if (jj_scan_token(LPAREN)) return true;
3348    if (jj_3R_22()) return true;
3349    if (jj_scan_token(COMMA)) return true;
3350    if (jj_3R_22()) return true;
3351    if (jj_scan_token(RPAREN)) return true;
3352    return false;
3353  }
3354
3355  final private boolean jj_3R_87() {
3356    Token xsp;
3357    xsp = jj_scanpos;
3358    if (jj_3R_99()) {
3359    jj_scanpos = xsp;
3360    if (jj_3R_100()) return true;
3361    }
3362    return false;
3363  }
3364
3365  final private boolean jj_3R_67() {
3366    if (jj_3R_89()) return true;
3367    return false;
3368  }
3369
3370  final private boolean jj_3R_39() {
3371    if (jj_3R_78()) return true;
3372    Token xsp;
3373    while (true) {
3374      xsp = jj_scanpos;
3375      if (jj_3R_79()) { jj_scanpos = xsp; break; }
3376    }
3377    return false;
3378  }
3379
3380  final private boolean jj_3R_103() {
3381    if (jj_scan_token(LPAREN)) return true;
3382    if (jj_3R_22()) return true;
3383    if (jj_scan_token(RPAREN)) return true;
3384    return false;
3385  }
3386
3387  final private boolean jj_3R_71() {
3388    if (jj_3R_27()) return true;
3389    return false;
3390  }
3391
3392  final private boolean jj_3R_28() {
3393    Token xsp;
3394    xsp = jj_scanpos;
3395    if (jj_3R_71()) {
3396    jj_scanpos = xsp;
3397    if (jj_3R_72()) return true;
3398    }
3399    return false;
3400  }
3401
3402  final private boolean jj_3R_11() {
3403    if (jj_3R_39()) return true;
3404    Token xsp;
3405    while (true) {
3406      xsp = jj_scanpos;
3407      if (jj_3R_40()) { jj_scanpos = xsp; break; }
3408    }
3409    return false;
3410  }
3411
3412  final private boolean jj_3_18() {
3413    if (jj_3R_19()) return true;
3414    return false;
3415  }
3416
3417  final private boolean jj_3R_27() {
3418    Token xsp;
3419    xsp = jj_scanpos;
3420    if (jj_3_18()) {
3421    jj_scanpos = xsp;
3422    if (jj_3_19()) return true;
3423    }
3424    return false;
3425  }
3426
3427  final private boolean jj_3R_70() {
3428    if (jj_3R_84()) return true;
3429    return false;
3430  }
3431
3432  final private boolean jj_3R_66() {
3433    if (jj_3R_47()) return true;
3434    return false;
3435  }
3436
3437  final private boolean jj_3R_24() {
3438    Token xsp;
3439    xsp = jj_scanpos;
3440    if (jj_3R_66()) {
3441    jj_scanpos = xsp;
3442    if (jj_3R_67()) {
3443    jj_scanpos = xsp;
3444    if (jj_3R_68()) return true;
3445    }
3446    }
3447    return false;
3448  }
3449
3450  public EJBQLTokenManager token_source;
3451  SimpleCharStream jj_input_stream;
3452  public Token token, jj_nt;
3453  private int jj_ntk;
3454  private Token jj_scanpos, jj_lastpos;
3455  private int jj_la;
3456  public boolean lookingAhead = false;
3457  private boolean jj_semLA;
3458  private int jj_gen;
3459  final private int[] jj_la1 = new int[63];
3460  static private int[] jj_la1_0;
3461  static private int[] jj_la1_1;
3462  static private int[] jj_la1_2;
3463  static {
3464      jj_la1_0();
3465      jj_la1_1();
3466      jj_la1_2();
3467   }
3468   private static void jj_la1_0() {
3469      jj_la1_0 = new int[] {0x0,0x0,0x0,0x4000,0x0,0x200000,0x200000,0x10000000,0x4800000,0x4800000,0x800000,0x10000000,0x10000000,0x0,0x4800000,0x4000,0x8400000,0x8400000,0x4000,0x0,0x0,0x100000,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x52680,0x10200,0x52680,0x10200,0x52680,0x80000,0x120,0x120,0x840,0x840,0x120,0x120,0xa0000,0x2000000,0x2020000,0x2020000,0x0,0x0,0x0,0x2000000,0x4000,0x80000,0x0,0x1000,0x0,0x0,0x0,};
3470   }
3471   private static void jj_la1_1() {
3472      jj_la1_1 = new int[] {0x100000,0x8000,0x10,0x0,0x80000001,0x0,0x0,0x0,0x80081140,0x80080140,0x80140,0x0,0x0,0x80000000,0x80140,0x0,0x0,0x0,0x0,0x2400000,0x4000,0x0,0x400,0x400,0x400,0x23e00000,0x0,0x23e00000,0x400,0x0,0x80400000,0x400,0x400,0x400000,0x400,0x2000,0x0,0x0,0x0,0x0,0x0,0x80020224,0x0,0x0,0x0,0x0,0x0,0x0,0xa2420224,0x80040000,0x80640000,0x80240000,0x80400000,0x81c00000,0x80400000,0x40000,0x0,0x20224,0x600000,0x0,0x23a00000,0x22000000,0x1800000,};
3473   }
3474   private static void jj_la1_2() {
3475      jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
3476   }
3477  final private JJCalls[] jj_2_rtns = new JJCalls[19];
3478  private boolean jj_rescan = false;
3479  private int jj_gc = 0;
3480
3481  public EJBQL(java.io.InputStream JavaDoc stream) {
3482    jj_input_stream = new SimpleCharStream(stream, 1, 1);
3483    token_source = new EJBQLTokenManager(jj_input_stream);
3484    token = new Token();
3485    jj_ntk = -1;
3486    jj_gen = 0;
3487    for (int i = 0; i < 63; i++) jj_la1[i] = -1;
3488    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3489  }
3490
3491  public void ReInit(java.io.InputStream JavaDoc stream) {
3492    jj_input_stream.ReInit(stream, 1, 1);
3493    token_source.ReInit(jj_input_stream);
3494    token = new Token();
3495    jj_ntk = -1;
3496    jjtree.reset();
3497    jj_gen = 0;
3498    for (int i = 0; i < 63; i++) jj_la1[i] = -1;
3499    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3500  }
3501
3502  public EJBQL(java.io.Reader JavaDoc stream) {
3503    jj_input_stream = new SimpleCharStream(stream, 1, 1);
3504    token_source = new EJBQLTokenManager(jj_input_stream);
3505    token = new Token();
3506    jj_ntk = -1;
3507    jj_gen = 0;
3508    for (int i = 0; i < 63; i++) jj_la1[i] = -1;
3509    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3510  }
3511
3512  public void ReInit(java.io.Reader JavaDoc stream) {
3513    jj_input_stream.ReInit(stream, 1, 1);
3514    token_source.ReInit(jj_input_stream);
3515    token = new Token();
3516    jj_ntk = -1;
3517    jjtree.reset();
3518    jj_gen = 0;
3519    for (int i = 0; i < 63; i++) jj_la1[i] = -1;
3520    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3521  }
3522
3523  public EJBQL(EJBQLTokenManager tm) {
3524    token_source = tm;
3525    token = new Token();
3526    jj_ntk = -1;
3527    jj_gen = 0;
3528    for (int i = 0; i < 63; i++) jj_la1[i] = -1;
3529    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3530  }
3531
3532  public void ReInit(EJBQLTokenManager tm) {
3533    token_source = tm;
3534    token = new Token();
3535    jj_ntk = -1;
3536    jjtree.reset();
3537    jj_gen = 0;
3538    for (int i = 0; i < 63; i++) jj_la1[i] = -1;
3539    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3540  }
3541
3542  final private Token jj_consume_token(int kind) throws ParseException {
3543    Token oldToken;
3544    if ((oldToken = token).next != null) token = token.next;
3545    else token = token.next = token_source.getNextToken();
3546    jj_ntk = -1;
3547    if (token.kind == kind) {
3548      jj_gen++;
3549      if (++jj_gc > 100) {
3550        jj_gc = 0;
3551        for (int i = 0; i < jj_2_rtns.length; i++) {
3552          JJCalls c = jj_2_rtns[i];
3553          while (c != null) {
3554            if (c.gen < jj_gen) c.first = null;
3555            c = c.next;
3556          }
3557        }
3558      }
3559      return token;
3560    }
3561    token = oldToken;
3562    jj_kind = kind;
3563    throw generateParseException();
3564  }
3565
3566  static private final class LookaheadSuccess extends java.lang.Error JavaDoc { }
3567  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3568  final private boolean jj_scan_token(int kind) {
3569    if (jj_scanpos == jj_lastpos) {
3570      jj_la--;
3571      if (jj_scanpos.next == null) {
3572        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3573      } else {
3574        jj_lastpos = jj_scanpos = jj_scanpos.next;
3575      }
3576    } else {
3577      jj_scanpos = jj_scanpos.next;
3578    }
3579    if (jj_rescan) {
3580      int i = 0; Token tok = token;
3581      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3582      if (tok != null) jj_add_error_token(kind, i);
3583    }
3584    if (jj_scanpos.kind != kind) return true;
3585    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
3586    return false;
3587  }
3588
3589  final public Token getNextToken() {
3590    if (token.next != null) token = token.next;
3591    else token = token.next = token_source.getNextToken();
3592    jj_ntk = -1;
3593    jj_gen++;
3594    return token;
3595  }
3596
3597  final public Token getToken(int index) {
3598    Token t = lookingAhead ? jj_scanpos : token;
3599    for (int i = 0; i < index; i++) {
3600      if (t.next != null) t = t.next;
3601      else t = t.next = token_source.getNextToken();
3602    }
3603    return t;
3604  }
3605
3606  final private int jj_ntk() {
3607    if ((jj_nt=token.next) == null)
3608      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
3609    else
3610      return (jj_ntk = jj_nt.kind);
3611  }
3612
3613  private java.util.Vector JavaDoc jj_expentries = new java.util.Vector JavaDoc();
3614  private int[] jj_expentry;
3615  private int jj_kind = -1;
3616  private int[] jj_lasttokens = new int[100];
3617  private int jj_endpos;
3618
3619  private void jj_add_error_token(int kind, int pos) {
3620    if (pos >= 100) return;
3621    if (pos == jj_endpos + 1) {
3622      jj_lasttokens[jj_endpos++] = kind;
3623    } else if (jj_endpos != 0) {
3624      jj_expentry = new int[jj_endpos];
3625      for (int i = 0; i < jj_endpos; i++) {
3626        jj_expentry[i] = jj_lasttokens[i];
3627      }
3628      boolean exists = false;
3629      for (java.util.Enumeration JavaDoc e = jj_expentries.elements(); e.hasMoreElements();) {
3630        int[] oldentry = (int[])(e.nextElement());
3631        if (oldentry.length == jj_expentry.length) {
3632          exists = true;
3633          for (int i = 0; i < jj_expentry.length; i++) {
3634            if (oldentry[i] != jj_expentry[i]) {
3635              exists = false;
3636              break;
3637            }
3638          }
3639          if (exists) break;
3640        }
3641      }
3642      if (!exists) jj_expentries.addElement(jj_expentry);
3643      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3644    }
3645  }
3646
3647  public ParseException generateParseException() {
3648    jj_expentries.removeAllElements();
3649    boolean[] la1tokens = new boolean[66];
3650    for (int i = 0; i < 66; i++) {
3651      la1tokens[i] = false;
3652    }
3653    if (jj_kind >= 0) {
3654      la1tokens[jj_kind] = true;
3655      jj_kind = -1;
3656    }
3657    for (int i = 0; i < 63; i++) {
3658      if (jj_la1[i] == jj_gen) {
3659        for (int j = 0; j < 32; j++) {
3660          if ((jj_la1_0[i] & (1<<j)) != 0) {
3661            la1tokens[j] = true;
3662          }
3663          if ((jj_la1_1[i] & (1<<j)) != 0) {
3664            la1tokens[32+j] = true;
3665          }
3666          if ((jj_la1_2[i] & (1<<j)) != 0) {
3667            la1tokens[64+j] = true;
3668          }
3669        }
3670      }
3671    }
3672    for (int i = 0; i < 66; i++) {
3673      if (la1tokens[i]) {
3674        jj_expentry = new int[1];
3675        jj_expentry[0] = i;
3676        jj_expentries.addElement(jj_expentry);
3677      }
3678    }
3679    jj_endpos = 0;
3680    jj_rescan_token();
3681    jj_add_error_token(0, 0);
3682    int[][] exptokseq = new int[jj_expentries.size()][];
3683    for (int i = 0; i < jj_expentries.size(); i++) {
3684      exptokseq[i] = (int[])jj_expentries.elementAt(i);
3685    }
3686    return new ParseException(token, exptokseq, tokenImage);
3687  }
3688
3689  final public void enable_tracing() {
3690  }
3691
3692  final public void disable_tracing() {
3693  }
3694
3695  final private void jj_rescan_token() {
3696    jj_rescan = true;
3697    for (int i = 0; i < 19; i++) {
3698      JJCalls p = jj_2_rtns[i];
3699      do {
3700        if (p.gen > jj_gen) {
3701          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3702          switch (i) {
3703            case 0: jj_3_1(); break;
3704            case 1: jj_3_2(); break;
3705            case 2: jj_3_3(); break;
3706            case 3: jj_3_4(); break;
3707            case 4: jj_3_5(); break;
3708            case 5: jj_3_6(); break;
3709            case 6: jj_3_7(); break;
3710            case 7: jj_3_8(); break;
3711            case 8: jj_3_9(); break;
3712            case 9: jj_3_10(); break;
3713            case 10: jj_3_11(); break;
3714            case 11: jj_3_12(); break;
3715            case 12: jj_3_13(); break;
3716            case 13: jj_3_14(); break;
3717            case 14: jj_3_15(); break;
3718            case 15: jj_3_16(); break;
3719            case 16: jj_3_17(); break;
3720            case 17: jj_3_18(); break;
3721            case 18: jj_3_19(); break;
3722          }
3723        }
3724        p = p.next;
3725      } while (p != null);
3726    }
3727    jj_rescan = false;
3728  }
3729
3730  final private void jj_save(int index, int xla) {
3731    JJCalls p = jj_2_rtns[index];
3732    while (p.gen > jj_gen) {
3733      if (p.next == null) { p = p.next = new JJCalls(); break; }
3734      p = p.next;
3735    }
3736    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3737  }
3738
3739  static final class JJCalls {
3740    int gen;
3741    Token first;
3742    int arg;
3743    JJCalls next;
3744  }
3745
3746}
3747
Popular Tags