KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > cayenne > ejbql > parser > EJBQL


1 /* Generated By:JJTree&JavaCC: Do not edit this line. EJBQL.java */
2 package org.apache.cayenne.ejbql.parser;
3
4 import java.io.*;
5 import java.util.*;
6 import org.apache.cayenne.ejbql.*;
7 import org.apache.cayenne.map.*;
8
9 public class EJBQL/*@bgen(jjtree)*/implements EJBQLTreeConstants, EJBQLConstants {/*@bgen(jjtree)*/
10   protected JJTEJBQLState jjtree = new JJTEJBQLState();
11         public EJBQL (String JavaDoc source) {
12                 this (new StringReader (source));
13         }
14
15     public static class EJBQLDefaultParser implements EJBQLParser {
16
17        public EJBQLExpression parse(String JavaDoc ejbqlStatement) throws EJBQLException {
18            try {
19               return new EJBQL(ejbqlStatement).parseQuery();
20            }
21            catch(ParseException e) {
22               throw new EJBQLException("Error parsing EJB QL statement", e);
23            }
24        }
25
26        public EJBQLCompiledExpression compile(String JavaDoc ejbqlStatement, EntityResolver resolver) throws EJBQLException {
27            try {
28               return new Compiler JavaDoc(resolver).compile(ejbqlStatement, new EJBQL(ejbqlStatement).parseQuery());
29            }
30            catch(ParseException e) {
31               throw new EJBQLException("Error parsing EJB QL statement", e);
32            }
33        }
34     }
35
36   final public Node parseQuery() throws ParseException {
37     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
38     case SELECT:
39       select_statement();
40       break;
41     case UPDATE:
42       update_statement();
43       break;
44     case DELETE:
45       delete_statement();
46       break;
47     default:
48       jj_la1[0] = jj_gen;
49       jj_consume_token(-1);
50       throw new ParseException();
51     }
52     jj_consume_token(0);
53                 {if (true) return jjtree.rootNode();}
54     throw new Error JavaDoc("Missing return statement in function");
55   }
56
57   final public void select_statement() throws ParseException {
58                                    /*@bgen(jjtree) Select */
59   EJBQLSelect jjtn000 = new EJBQLSelect(JJTSELECT);
60   boolean jjtc000 = true;
61   jjtree.openNodeScope(jjtn000);
62     try {
63       select_clause();
64       from_clause();
65       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
66       case WHERE:
67         where_clause();
68         break;
69       default:
70         jj_la1[1] = jj_gen;
71         ;
72       }
73       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
74       case GROUP:
75         groupby_clause();
76         break;
77       default:
78         jj_la1[2] = jj_gen;
79         ;
80       }
81       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
82       case HAVING:
83         having_clause();
84         break;
85       default:
86         jj_la1[3] = jj_gen;
87         ;
88       }
89       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
90       case ORDER:
91         orderby_clause();
92         break;
93       default:
94         jj_la1[4] = jj_gen;
95         ;
96       }
97     } catch (Throwable JavaDoc jjte000) {
98           if (jjtc000) {
99             jjtree.clearNodeScope(jjtn000);
100             jjtc000 = false;
101           } else {
102             jjtree.popNode();
103           }
104           if (jjte000 instanceof RuntimeException JavaDoc) {
105             {if (true) throw (RuntimeException JavaDoc)jjte000;}
106           }
107           if (jjte000 instanceof ParseException) {
108             {if (true) throw (ParseException)jjte000;}
109           }
110           {if (true) throw (Error JavaDoc)jjte000;}
111     } finally {
112           if (jjtc000) {
113             jjtree.closeNodeScope(jjtn000, true);
114           }
115     }
116   }
117
118   final public void update_statement() throws ParseException {
119                                    /*@bgen(jjtree) Update */
120   EJBQLUpdate jjtn000 = new EJBQLUpdate(JJTUPDATE);
121   boolean jjtc000 = true;
122   jjtree.openNodeScope(jjtn000);
123     try {
124       update_clause();
125       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
126       case WHERE:
127         where_clause();
128         break;
129       default:
130         jj_la1[5] = jj_gen;
131         ;
132       }
133     } catch (Throwable JavaDoc jjte000) {
134           if (jjtc000) {
135             jjtree.clearNodeScope(jjtn000);
136             jjtc000 = false;
137           } else {
138             jjtree.popNode();
139           }
140           if (jjte000 instanceof RuntimeException JavaDoc) {
141             {if (true) throw (RuntimeException JavaDoc)jjte000;}
142           }
143           if (jjte000 instanceof ParseException) {
144             {if (true) throw (ParseException)jjte000;}
145           }
146           {if (true) throw (Error JavaDoc)jjte000;}
147     } finally {
148           if (jjtc000) {
149             jjtree.closeNodeScope(jjtn000, true);
150           }
151     }
152   }
153
154   final public void delete_statement() throws ParseException {
155                                    /*@bgen(jjtree) Delete */
156   EJBQLDelete jjtn000 = new EJBQLDelete(JJTDELETE);
157   boolean jjtc000 = true;
158   jjtree.openNodeScope(jjtn000);
159     try {
160       jj_consume_token(DELETE);
161       jj_consume_token(FROM);
162                            EJBQLFrom jjtn001 = new EJBQLFrom(JJTFROM);
163                            boolean jjtc001 = true;
164                            jjtree.openNodeScope(jjtn001);
165       try {
166         from_item();
167       } catch (Throwable JavaDoc jjte001) {
168                            if (jjtc001) {
169                              jjtree.clearNodeScope(jjtn001);
170                              jjtc001 = false;
171                            } else {
172                              jjtree.popNode();
173                            }
174                            if (jjte001 instanceof RuntimeException JavaDoc) {
175                              {if (true) throw (RuntimeException JavaDoc)jjte001;}
176                            }
177                            if (jjte001 instanceof ParseException) {
178                              {if (true) throw (ParseException)jjte001;}
179                            }
180                            {if (true) throw (Error JavaDoc)jjte001;}
181       } finally {
182                            if (jjtc001) {
183                              jjtree.closeNodeScope(jjtn001, true);
184                            }
185       }
186       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
187       case WHERE:
188         where_clause();
189         break;
190       default:
191         jj_la1[6] = jj_gen;
192         ;
193       }
194     } catch (Throwable JavaDoc jjte000) {
195           if (jjtc000) {
196             jjtree.clearNodeScope(jjtn000);
197             jjtc000 = false;
198           } else {
199             jjtree.popNode();
200           }
201           if (jjte000 instanceof RuntimeException JavaDoc) {
202             {if (true) throw (RuntimeException JavaDoc)jjte000;}
203           }
204           if (jjte000 instanceof ParseException) {
205             {if (true) throw (ParseException)jjte000;}
206           }
207           {if (true) throw (Error JavaDoc)jjte000;}
208     } finally {
209           if (jjtc000) {
210             jjtree.closeNodeScope(jjtn000, true);
211           }
212     }
213   }
214
215   final public void from_clause() throws ParseException {
216                             /*@bgen(jjtree) From */
217   EJBQLFrom jjtn000 = new EJBQLFrom(JJTFROM);
218   boolean jjtc000 = true;
219   jjtree.openNodeScope(jjtn000);
220     try {
221       jj_consume_token(FROM);
222       identification_variable_declaration();
223       label_1:
224       while (true) {
225         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
226         case COMMA:
227           ;
228           break;
229         default:
230           jj_la1[7] = jj_gen;
231           break label_1;
232         }
233         jj_consume_token(COMMA);
234         if (jj_2_1(2147483647)) {
235           collection_member_declaration();
236         } else if (jj_2_2(2147483647)) {
237           identification_variable_declaration();
238         } else {
239           jj_consume_token(-1);
240           throw new ParseException();
241         }
242       }
243     } catch (Throwable JavaDoc jjte000) {
244           if (jjtc000) {
245             jjtree.clearNodeScope(jjtn000);
246             jjtc000 = false;
247           } else {
248             jjtree.popNode();
249           }
250           if (jjte000 instanceof RuntimeException JavaDoc) {
251             {if (true) throw (RuntimeException JavaDoc)jjte000;}
252           }
253           if (jjte000 instanceof ParseException) {
254             {if (true) throw (ParseException)jjte000;}
255           }
256           {if (true) throw (Error JavaDoc)jjte000;}
257     } finally {
258           if (jjtc000) {
259             jjtree.closeNodeScope(jjtn000, true);
260           }
261     }
262   }
263
264   final public void identification_variable_declaration() throws ParseException {
265     from_item();
266     label_2:
267     while (true) {
268       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
269       case LEFT:
270       case INNER:
271       case JOIN:
272         ;
273         break;
274       default:
275         jj_la1[8] = jj_gen;
276         break label_2;
277       }
278       if (jj_2_3(2147483647)) {
279         fetch_join();
280       } else if (jj_2_4(2147483647)) {
281         inner_join();
282       } else if (jj_2_5(2147483647)) {
283         outer_join();
284       } else {
285         jj_consume_token(-1);
286         throw new ParseException();
287       }
288     }
289   }
290
291   final public void from_item() throws ParseException {
292                               /*@bgen(jjtree) FromItem */
293   EJBQLFromItem jjtn000 = new EJBQLFromItem(JJTFROMITEM);
294   boolean jjtc000 = true;
295   jjtree.openNodeScope(jjtn000);
296     try {
297       abstract_schema_name();
298       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
299       case AS:
300         jj_consume_token(AS);
301         break;
302       default:
303         jj_la1[9] = jj_gen;
304         ;
305       }
306       if (jj_2_6(2147483647)) {
307         identification_variable();
308       } else {
309         ;
310       }
311     } catch (Throwable JavaDoc jjte000) {
312           if (jjtc000) {
313             jjtree.clearNodeScope(jjtn000);
314             jjtc000 = false;
315           } else {
316             jjtree.popNode();
317           }
318           if (jjte000 instanceof RuntimeException JavaDoc) {
319             {if (true) throw (RuntimeException JavaDoc)jjte000;}
320           }
321           if (jjte000 instanceof ParseException) {
322             {if (true) throw (ParseException)jjte000;}
323           }
324           {if (true) throw (Error JavaDoc)jjte000;}
325     } finally {
326           if (jjtc000) {
327             jjtree.closeNodeScope(jjtn000, true);
328           }
329     }
330   }
331
332   final public void subquery_from_clause() throws ParseException {
333                                      /*@bgen(jjtree) From */
334   EJBQLFrom jjtn000 = new EJBQLFrom(JJTFROM);
335   boolean jjtc000 = true;
336   jjtree.openNodeScope(jjtn000);
337     try {
338       jj_consume_token(FROM);
339       subquery_from_item();
340       label_3:
341       while (true) {
342         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
343         case COMMA:
344           ;
345           break;
346         default:
347           jj_la1[10] = jj_gen;
348           break label_3;
349         }
350         jj_consume_token(COMMA);
351         subquery_from_item();
352       }
353     } catch (Throwable JavaDoc jjte000) {
354           if (jjtc000) {
355             jjtree.clearNodeScope(jjtn000);
356             jjtc000 = false;
357           } else {
358             jjtree.popNode();
359           }
360           if (jjte000 instanceof RuntimeException JavaDoc) {
361             {if (true) throw (RuntimeException JavaDoc)jjte000;}
362           }
363           if (jjte000 instanceof ParseException) {
364             {if (true) throw (ParseException)jjte000;}
365           }
366           {if (true) throw (Error JavaDoc)jjte000;}
367     } finally {
368           if (jjtc000) {
369             jjtree.closeNodeScope(jjtn000, true);
370           }
371     }
372   }
373
374   final public void subquery_from_item() throws ParseException {
375     if (jj_2_7(2147483647)) {
376       collection_member_declaration();
377     } else if (jj_2_8(2147483647)) {
378       identification_variable_declaration();
379     } else {
380       jj_consume_token(-1);
381       throw new ParseException();
382     }
383   }
384
385   final public void inner_join() throws ParseException {
386                                 /*@bgen(jjtree) InnerJoin */
387   EJBQLInnerJoin jjtn000 = new EJBQLInnerJoin(JJTINNERJOIN);
388   boolean jjtc000 = true;
389   jjtree.openNodeScope(jjtn000);
390     try {
391       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
392       case INNER:
393         jj_consume_token(INNER);
394         break;
395       default:
396         jj_la1[11] = jj_gen;
397         ;
398       }
399       jj_consume_token(JOIN);
400       path();
401       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
402       case AS:
403         jj_consume_token(AS);
404         break;
405       default:
406         jj_la1[12] = jj_gen;
407         ;
408       }
409       identification_variable();
410     } catch (Throwable JavaDoc jjte000) {
411           if (jjtc000) {
412             jjtree.clearNodeScope(jjtn000);
413             jjtc000 = false;
414           } else {
415             jjtree.popNode();
416           }
417           if (jjte000 instanceof RuntimeException JavaDoc) {
418             {if (true) throw (RuntimeException JavaDoc)jjte000;}
419           }
420           if (jjte000 instanceof ParseException) {
421             {if (true) throw (ParseException)jjte000;}
422           }
423           {if (true) throw (Error JavaDoc)jjte000;}
424     } finally {
425           if (jjtc000) {
426             jjtree.closeNodeScope(jjtn000, true);
427           }
428     }
429   }
430
431   final public void collection_member_declaration() throws ParseException {
432                                                    /*@bgen(jjtree) InnerJoin */
433   EJBQLInnerJoin jjtn000 = new EJBQLInnerJoin(JJTINNERJOIN);
434   boolean jjtc000 = true;
435   jjtree.openNodeScope(jjtn000);
436     try {
437       jj_consume_token(IN);
438       jj_consume_token(84);
439       path();
440       jj_consume_token(85);
441       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
442       case AS:
443         jj_consume_token(AS);
444         break;
445       default:
446         jj_la1[13] = jj_gen;
447         ;
448       }
449       identification_variable();
450     } catch (Throwable JavaDoc jjte000) {
451           if (jjtc000) {
452             jjtree.clearNodeScope(jjtn000);
453             jjtc000 = false;
454           } else {
455             jjtree.popNode();
456           }
457           if (jjte000 instanceof RuntimeException JavaDoc) {
458             {if (true) throw (RuntimeException JavaDoc)jjte000;}
459           }
460           if (jjte000 instanceof ParseException) {
461             {if (true) throw (ParseException)jjte000;}
462           }
463           {if (true) throw (Error JavaDoc)jjte000;}
464     } finally {
465           if (jjtc000) {
466             jjtree.closeNodeScope(jjtn000, true);
467           }
468     }
469   }
470
471   final public void outer_join() throws ParseException {
472                                 /*@bgen(jjtree) OuterJoin */
473   EJBQLOuterJoin jjtn000 = new EJBQLOuterJoin(JJTOUTERJOIN);
474   boolean jjtc000 = true;
475   jjtree.openNodeScope(jjtn000);
476     try {
477       jj_consume_token(LEFT);
478       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
479       case OUTER:
480         jj_consume_token(OUTER);
481         break;
482       default:
483         jj_la1[14] = jj_gen;
484         ;
485       }
486       jj_consume_token(JOIN);
487       path();
488       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
489       case AS:
490         jj_consume_token(AS);
491         break;
492       default:
493         jj_la1[15] = jj_gen;
494         ;
495       }
496       identification_variable();
497     } catch (Throwable JavaDoc jjte000) {
498           if (jjtc000) {
499             jjtree.clearNodeScope(jjtn000);
500             jjtc000 = false;
501           } else {
502             jjtree.popNode();
503           }
504           if (jjte000 instanceof RuntimeException JavaDoc) {
505             {if (true) throw (RuntimeException JavaDoc)jjte000;}
506           }
507           if (jjte000 instanceof ParseException) {
508             {if (true) throw (ParseException)jjte000;}
509           }
510           {if (true) throw (Error JavaDoc)jjte000;}
511     } finally {
512           if (jjtc000) {
513             jjtree.closeNodeScope(jjtn000, true);
514           }
515     }
516   }
517
518   final public void fetch_join() throws ParseException {
519     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
520     case LEFT:
521       outer_fetch_join();
522       break;
523     case INNER:
524     case JOIN:
525       inner_fetch_join();
526       break;
527     default:
528       jj_la1[16] = jj_gen;
529       jj_consume_token(-1);
530       throw new ParseException();
531     }
532   }
533
534   final public void outer_fetch_join() throws ParseException {
535                                            /*@bgen(jjtree) OuterFetchJoin */
536   EJBQLOuterFetchJoin jjtn000 = new EJBQLOuterFetchJoin(JJTOUTERFETCHJOIN);
537   boolean jjtc000 = true;
538   jjtree.openNodeScope(jjtn000);
539     try {
540       jj_consume_token(LEFT);
541       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
542       case OUTER:
543         jj_consume_token(OUTER);
544         break;
545       default:
546         jj_la1[17] = jj_gen;
547         ;
548       }
549       jj_consume_token(JOIN);
550       jj_consume_token(FETCH);
551       path();
552     } catch (Throwable JavaDoc jjte000) {
553           if (jjtc000) {
554             jjtree.clearNodeScope(jjtn000);
555             jjtc000 = false;
556           } else {
557             jjtree.popNode();
558           }
559           if (jjte000 instanceof RuntimeException JavaDoc) {
560             {if (true) throw (RuntimeException JavaDoc)jjte000;}
561           }
562           if (jjte000 instanceof ParseException) {
563             {if (true) throw (ParseException)jjte000;}
564           }
565           {if (true) throw (Error JavaDoc)jjte000;}
566     } finally {
567           if (jjtc000) {
568             jjtree.closeNodeScope(jjtn000, true);
569           }
570     }
571   }
572
573   final public void inner_fetch_join() throws ParseException {
574                                            /*@bgen(jjtree) InnerFetchJoin */
575   EJBQLInnerFetchJoin jjtn000 = new EJBQLInnerFetchJoin(JJTINNERFETCHJOIN);
576   boolean jjtc000 = true;
577   jjtree.openNodeScope(jjtn000);
578     try {
579       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
580       case INNER:
581         jj_consume_token(INNER);
582         break;
583       default:
584         jj_la1[18] = jj_gen;
585         ;
586       }
587       jj_consume_token(JOIN);
588       jj_consume_token(FETCH);
589       path();
590     } catch (Throwable JavaDoc jjte000) {
591           if (jjtc000) {
592             jjtree.clearNodeScope(jjtn000);
593             jjtc000 = false;
594           } else {
595             jjtree.popNode();
596           }
597           if (jjte000 instanceof RuntimeException JavaDoc) {
598             {if (true) throw (RuntimeException JavaDoc)jjte000;}
599           }
600           if (jjte000 instanceof ParseException) {
601             {if (true) throw (ParseException)jjte000;}
602           }
603           {if (true) throw (Error JavaDoc)jjte000;}
604     } finally {
605           if (jjtc000) {
606             jjtree.closeNodeScope(jjtn000, true);
607           }
608     }
609   }
610
611   final public void path() throws ParseException {
612                      /*@bgen(jjtree) Path */
613   EJBQLPath jjtn000 = new EJBQLPath(JJTPATH);
614   boolean jjtc000 = true;
615   jjtree.openNodeScope(jjtn000);
616     try {
617       identification_variable();
618       label_4:
619       while (true) {
620         jj_consume_token(DOT);
621         path_component();
622         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
623         case DOT:
624           ;
625           break;
626         default:
627           jj_la1[19] = jj_gen;
628           break label_4;
629         }
630       }
631     } catch (Throwable JavaDoc jjte000) {
632           if (jjtc000) {
633             jjtree.clearNodeScope(jjtn000);
634             jjtc000 = false;
635           } else {
636             jjtree.popNode();
637           }
638           if (jjte000 instanceof RuntimeException JavaDoc) {
639             {if (true) throw (RuntimeException JavaDoc)jjte000;}
640           }
641           if (jjte000 instanceof ParseException) {
642             {if (true) throw (ParseException)jjte000;}
643           }
644           {if (true) throw (Error JavaDoc)jjte000;}
645     } finally {
646           if (jjtc000) {
647             jjtree.closeNodeScope(jjtn000, true);
648           }
649     }
650   }
651
652   final public void update_clause() throws ParseException {
653     jj_consume_token(UPDATE);
654                    EJBQLFrom jjtn001 = new EJBQLFrom(JJTFROM);
655                    boolean jjtc001 = true;
656                    jjtree.openNodeScope(jjtn001);
657     try {
658       from_item();
659     } catch (Throwable JavaDoc jjte001) {
660                    if (jjtc001) {
661                      jjtree.clearNodeScope(jjtn001);
662                      jjtc001 = false;
663                    } else {
664                      jjtree.popNode();
665                    }
666                    if (jjte001 instanceof RuntimeException JavaDoc) {
667                      {if (true) throw (RuntimeException JavaDoc)jjte001;}
668                    }
669                    if (jjte001 instanceof ParseException) {
670                      {if (true) throw (ParseException)jjte001;}
671                    }
672                    {if (true) throw (Error JavaDoc)jjte001;}
673     } finally {
674                    if (jjtc001) {
675                      jjtree.closeNodeScope(jjtn001, true);
676                    }
677     }
678     set_clause();
679   }
680
681   final public void set_clause() throws ParseException {
682     jj_consume_token(SET);
683     update_item();
684     label_5:
685     while (true) {
686       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
687       case COMMA:
688         ;
689         break;
690       default:
691         jj_la1[20] = jj_gen;
692         break label_5;
693       }
694       jj_consume_token(COMMA);
695       update_item();
696     }
697   }
698
699   final public void update_item() throws ParseException {
700                                   /*@bgen(jjtree) UpdateItem */
701   EJBQLUpdateItem jjtn000 = new EJBQLUpdateItem(JJTUPDATEITEM);
702   boolean jjtc000 = true;
703   jjtree.openNodeScope(jjtn000);
704     try {
705       update_field();
706       EQ();
707       new_value();
708     } catch (Throwable JavaDoc jjte000) {
709           if (jjtc000) {
710             jjtree.clearNodeScope(jjtn000);
711             jjtc000 = false;
712           } else {
713             jjtree.popNode();
714           }
715           if (jjte000 instanceof RuntimeException JavaDoc) {
716             {if (true) throw (RuntimeException JavaDoc)jjte000;}
717           }
718           if (jjte000 instanceof ParseException) {
719             {if (true) throw (ParseException)jjte000;}
720           }
721           {if (true) throw (Error JavaDoc)jjte000;}
722     } finally {
723           if (jjtc000) {
724             jjtree.closeNodeScope(jjtn000, true);
725           }
726     }
727   }
728
729   final public void update_field() throws ParseException {
730                                     /*@bgen(jjtree) UpdateField */
731   EJBQLUpdateField jjtn000 = new EJBQLUpdateField(JJTUPDATEFIELD);
732   boolean jjtc000 = true;
733   jjtree.openNodeScope(jjtn000);
734     try {
735       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
736       case IDENTIFIER:
737         identification_variable();
738         jj_consume_token(DOT);
739         break;
740       default:
741         jj_la1[21] = jj_gen;
742         ;
743       }
744       path_component();
745     } catch (Throwable JavaDoc jjte000) {
746           if (jjtc000) {
747             jjtree.clearNodeScope(jjtn000);
748             jjtc000 = false;
749           } else {
750             jjtree.popNode();
751           }
752           if (jjte000 instanceof RuntimeException JavaDoc) {
753             {if (true) throw (RuntimeException JavaDoc)jjte000;}
754           }
755           if (jjte000 instanceof ParseException) {
756             {if (true) throw (ParseException)jjte000;}
757           }
758           {if (true) throw (Error JavaDoc)jjte000;}
759     } finally {
760           if (jjtc000) {
761             jjtree.closeNodeScope(jjtn000, true);
762           }
763     }
764   }
765
766   final public void new_value() throws ParseException {
767                                  /*@bgen(jjtree) UpdateValue */
768   EJBQLUpdateValue jjtn000 = new EJBQLUpdateValue(JJTUPDATEVALUE);
769   boolean jjtc000 = true;
770   jjtree.openNodeScope(jjtn000);
771     try {
772       if (jj_2_9(2147483647)) {
773         arithmetic_expression();
774       } else if (jj_2_10(2147483647)) {
775         string_primary();
776       } else if (jj_2_11(2147483647)) {
777         datetime_primary();
778       } else if (jj_2_12(2147483647)) {
779         boolean_primary();
780       } else if (jj_2_13(2147483647)) {
781         enum_primary();
782       } else if (jj_2_14(2147483647)) {
783         simple_entity_expression();
784       } else {
785         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
786         case NULL:
787           jj_consume_token(NULL);
788           break;
789         default:
790           jj_la1[22] = jj_gen;
791           jj_consume_token(-1);
792           throw new ParseException();
793         }
794       }
795     } catch (Throwable JavaDoc jjte000) {
796           if (jjtc000) {
797             jjtree.clearNodeScope(jjtn000);
798             jjtc000 = false;
799           } else {
800             jjtree.popNode();
801           }
802           if (jjte000 instanceof RuntimeException JavaDoc) {
803             {if (true) throw (RuntimeException JavaDoc)jjte000;}
804           }
805           if (jjte000 instanceof ParseException) {
806             {if (true) throw (ParseException)jjte000;}
807           }
808           {if (true) throw (Error JavaDoc)jjte000;}
809     } finally {
810           if (jjtc000) {
811             jjtree.closeNodeScope(jjtn000, true);
812           }
813     }
814   }
815
816   final public void simple_entity_expression() throws ParseException {
817     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
818     case IDENTIFIER:
819       identification_variable();
820       break;
821     case 86:
822     case 87:
823       input_parameter();
824       break;
825     default:
826       jj_la1[23] = jj_gen;
827       jj_consume_token(-1);
828       throw new ParseException();
829     }
830   }
831
832   final public void select_clause() throws ParseException {
833                                       /*@bgen(jjtree) SelectClause */
834   EJBQLSelectClause jjtn000 = new EJBQLSelectClause(JJTSELECTCLAUSE);
835   boolean jjtc000 = true;
836   jjtree.openNodeScope(jjtn000);
837     try {
838       jj_consume_token(SELECT);
839       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
840       case DISTINCT:
841         distinct();
842         break;
843       default:
844         jj_la1[24] = jj_gen;
845         ;
846       }
847       select_expressions();
848     } catch (Throwable JavaDoc jjte000) {
849           if (jjtc000) {
850             jjtree.clearNodeScope(jjtn000);
851             jjtc000 = false;
852           } else {
853             jjtree.popNode();
854           }
855           if (jjte000 instanceof RuntimeException JavaDoc) {
856             {if (true) throw (RuntimeException JavaDoc)jjte000;}
857           }
858           if (jjte000 instanceof ParseException) {
859             {if (true) throw (ParseException)jjte000;}
860           }
861           {if (true) throw (Error JavaDoc)jjte000;}
862     } finally {
863           if (jjtc000) {
864             jjtree.closeNodeScope(jjtn000, true);
865           }
866     }
867   }
868
869   final public void simple_select_clause() throws ParseException {
870                                              /*@bgen(jjtree) SelectClause */
871   EJBQLSelectClause jjtn000 = new EJBQLSelectClause(JJTSELECTCLAUSE);
872   boolean jjtc000 = true;
873   jjtree.openNodeScope(jjtn000);
874     try {
875       jj_consume_token(SELECT);
876       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
877       case DISTINCT:
878         distinct();
879         break;
880       default:
881         jj_la1[25] = jj_gen;
882         ;
883       }
884       subselect_expressions();
885     } catch (Throwable JavaDoc jjte000) {
886           if (jjtc000) {
887             jjtree.clearNodeScope(jjtn000);
888             jjtc000 = false;
889           } else {
890             jjtree.popNode();
891           }
892           if (jjte000 instanceof RuntimeException JavaDoc) {
893             {if (true) throw (RuntimeException JavaDoc)jjte000;}
894           }
895           if (jjte000 instanceof ParseException) {
896             {if (true) throw (ParseException)jjte000;}
897           }
898           {if (true) throw (Error JavaDoc)jjte000;}
899     } finally {
900           if (jjtc000) {
901             jjtree.closeNodeScope(jjtn000, true);
902           }
903     }
904   }
905
906   final public void select_expressions() throws ParseException {
907                                                 /*@bgen(jjtree) SelectExpressions */
908   EJBQLSelectExpressions jjtn000 = new EJBQLSelectExpressions(JJTSELECTEXPRESSIONS);
909   boolean jjtc000 = true;
910   jjtree.openNodeScope(jjtn000);
911     try {
912       select_expression();
913       label_6:
914       while (true) {
915         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
916         case COMMA:
917           ;
918           break;
919         default:
920           jj_la1[26] = jj_gen;
921           break label_6;
922         }
923         jj_consume_token(COMMA);
924         select_expression();
925       }
926     } catch (Throwable JavaDoc jjte000) {
927           if (jjtc000) {
928             jjtree.clearNodeScope(jjtn000);
929             jjtc000 = false;
930           } else {
931             jjtree.popNode();
932           }
933           if (jjte000 instanceof RuntimeException JavaDoc) {
934             {if (true) throw (RuntimeException JavaDoc)jjte000;}
935           }
936           if (jjte000 instanceof ParseException) {
937             {if (true) throw (ParseException)jjte000;}
938           }
939           {if (true) throw (Error JavaDoc)jjte000;}
940     } finally {
941           if (jjtc000) {
942             jjtree.closeNodeScope(jjtn000, true);
943           }
944     }
945   }
946
947   final public void select_expression() throws ParseException {
948                                               /*@bgen(jjtree) SelectExpression */
949   EJBQLSelectExpression jjtn000 = new EJBQLSelectExpression(JJTSELECTEXPRESSION);
950   boolean jjtc000 = true;
951   jjtree.openNodeScope(jjtn000);
952     try {
953       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
954       case AVG:
955       case MIN:
956       case MAX:
957       case SUM:
958       case COUNT:
959         aggregate_select_expression();
960         break;
961       default:
962         jj_la1[27] = jj_gen;
963         if (jj_2_15(2147483647)) {
964           path();
965         } else {
966           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
967           case IDENTIFIER:
968             identification_variable();
969             break;
970           case OBJECT:
971             jj_consume_token(OBJECT);
972             jj_consume_token(84);
973             identification_variable();
974             jj_consume_token(85);
975             break;
976           case NEW:
977             constructor_expression();
978             break;
979           default:
980             jj_la1[28] = jj_gen;
981             jj_consume_token(-1);
982             throw new ParseException();
983           }
984         }
985       }
986     } catch (Throwable JavaDoc jjte000) {
987           if (jjtc000) {
988             jjtree.clearNodeScope(jjtn000);
989             jjtc000 = false;
990           } else {
991             jjtree.popNode();
992           }
993           if (jjte000 instanceof RuntimeException JavaDoc) {
994             {if (true) throw (RuntimeException JavaDoc)jjte000;}
995           }
996           if (jjte000 instanceof ParseException) {
997             {if (true) throw (ParseException)jjte000;}
998           }
999           {if (true) throw (Error JavaDoc)jjte000;}
1000    } finally {
1001          if (jjtc000) {
1002            jjtree.closeNodeScope(jjtn000, true);
1003          }
1004    }
1005  }
1006
1007  final public void subselect_expressions() throws ParseException {
1008                                                   /*@bgen(jjtree) SelectExpressions */
1009  EJBQLSelectExpressions jjtn000 = new EJBQLSelectExpressions(JJTSELECTEXPRESSIONS);
1010  boolean jjtc000 = true;
1011  jjtree.openNodeScope(jjtn000);
1012    try {
1013      subselect_expression();
1014      label_7:
1015      while (true) {
1016        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1017        case COMMA:
1018          ;
1019          break;
1020        default:
1021          jj_la1[29] = jj_gen;
1022          break label_7;
1023        }
1024        jj_consume_token(COMMA);
1025        subselect_expression();
1026      }
1027    } catch (Throwable JavaDoc jjte000) {
1028          if (jjtc000) {
1029            jjtree.clearNodeScope(jjtn000);
1030            jjtc000 = false;
1031          } else {
1032            jjtree.popNode();
1033          }
1034          if (jjte000 instanceof RuntimeException JavaDoc) {
1035            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1036          }
1037          if (jjte000 instanceof ParseException) {
1038            {if (true) throw (ParseException)jjte000;}
1039          }
1040          {if (true) throw (Error JavaDoc)jjte000;}
1041    } finally {
1042          if (jjtc000) {
1043            jjtree.closeNodeScope(jjtn000, true);
1044          }
1045    }
1046  }
1047
1048  final public void subselect_expression() throws ParseException {
1049                                                 /*@bgen(jjtree) SelectExpression */
1050  EJBQLSelectExpression jjtn000 = new EJBQLSelectExpression(JJTSELECTEXPRESSION);
1051  boolean jjtc000 = true;
1052  jjtree.openNodeScope(jjtn000);
1053    try {
1054      if (jj_2_16(2147483647)) {
1055        path();
1056      } else {
1057        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1058        case AVG:
1059        case MIN:
1060        case MAX:
1061        case SUM:
1062        case COUNT:
1063          aggregate_select_expression();
1064          break;
1065        case IDENTIFIER:
1066          identification_variable();
1067          break;
1068        default:
1069          jj_la1[30] = jj_gen;
1070          jj_consume_token(-1);
1071          throw new ParseException();
1072        }
1073      }
1074    } catch (Throwable JavaDoc jjte000) {
1075          if (jjtc000) {
1076            jjtree.clearNodeScope(jjtn000);
1077            jjtc000 = false;
1078          } else {
1079            jjtree.popNode();
1080          }
1081          if (jjte000 instanceof RuntimeException JavaDoc) {
1082            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1083          }
1084          if (jjte000 instanceof ParseException) {
1085            {if (true) throw (ParseException)jjte000;}
1086          }
1087          {if (true) throw (Error JavaDoc)jjte000;}
1088    } finally {
1089          if (jjtc000) {
1090            jjtree.closeNodeScope(jjtn000, true);
1091          }
1092    }
1093  }
1094
1095  final public void constructor_expression() throws ParseException {
1096                                              /*@bgen(jjtree) Constructor */
1097  EJBQLConstructor jjtn000 = new EJBQLConstructor(JJTCONSTRUCTOR);
1098  boolean jjtc000 = true;
1099  jjtree.openNodeScope(jjtn000);
1100    try {
1101      jj_consume_token(NEW);
1102      classname();
1103      constructor_parameters();
1104    } catch (Throwable JavaDoc jjte000) {
1105          if (jjtc000) {
1106            jjtree.clearNodeScope(jjtn000);
1107            jjtc000 = false;
1108          } else {
1109            jjtree.popNode();
1110          }
1111          if (jjte000 instanceof RuntimeException JavaDoc) {
1112            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1113          }
1114          if (jjte000 instanceof ParseException) {
1115            {if (true) throw (ParseException)jjte000;}
1116          }
1117          {if (true) throw (Error JavaDoc)jjte000;}
1118    } finally {
1119          if (jjtc000) {
1120            jjtree.closeNodeScope(jjtn000, true);
1121          }
1122    }
1123  }
1124
1125  final public void classname() throws ParseException {
1126 /*@bgen(jjtree) ClassName */
1127  EJBQLClassName jjtn000 = new EJBQLClassName(JJTCLASSNAME);
1128  boolean jjtc000 = true;
1129  jjtree.openNodeScope(jjtn000);Token t;
1130    try {
1131      identification_variable();
1132      label_8:
1133      while (true) {
1134        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1135        case DOT:
1136          ;
1137          break;
1138        default:
1139          jj_la1[31] = jj_gen;
1140          break label_8;
1141        }
1142        jj_consume_token(DOT);
1143        identification_variable();
1144      }
1145    } catch (Throwable JavaDoc jjte000) {
1146          if (jjtc000) {
1147            jjtree.clearNodeScope(jjtn000);
1148            jjtc000 = false;
1149          } else {
1150            jjtree.popNode();
1151          }
1152          if (jjte000 instanceof RuntimeException JavaDoc) {
1153            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1154          }
1155          if (jjte000 instanceof ParseException) {
1156            {if (true) throw (ParseException)jjte000;}
1157          }
1158          {if (true) throw (Error JavaDoc)jjte000;}
1159    } finally {
1160          if (jjtc000) {
1161            jjtree.closeNodeScope(jjtn000, true);
1162          }
1163    }
1164  }
1165
1166  final public void constructor_parameters() throws ParseException {
1167                                                        /*@bgen(jjtree) ConstructorParameters */
1168  EJBQLConstructorParameters jjtn000 = new EJBQLConstructorParameters(JJTCONSTRUCTORPARAMETERS);
1169  boolean jjtc000 = true;
1170  jjtree.openNodeScope(jjtn000);
1171    try {
1172      jj_consume_token(84);
1173      constructor_parameter();
1174      label_9:
1175      while (true) {
1176        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1177        case COMMA:
1178          ;
1179          break;
1180        default:
1181          jj_la1[32] = jj_gen;
1182          break label_9;
1183        }
1184        jj_consume_token(COMMA);
1185        constructor_parameter();
1186      }
1187      jj_consume_token(85);
1188    } catch (Throwable JavaDoc jjte000) {
1189          if (jjtc000) {
1190            jjtree.clearNodeScope(jjtn000);
1191            jjtc000 = false;
1192          } else {
1193            jjtree.popNode();
1194          }
1195          if (jjte000 instanceof RuntimeException JavaDoc) {
1196            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1197          }
1198          if (jjte000 instanceof ParseException) {
1199            {if (true) throw (ParseException)jjte000;}
1200          }
1201          {if (true) throw (Error JavaDoc)jjte000;}
1202    } finally {
1203          if (jjtc000) {
1204            jjtree.closeNodeScope(jjtn000, true);
1205          }
1206    }
1207  }
1208
1209  final public void constructor_parameter() throws ParseException {
1210                                                      /*@bgen(jjtree) ConstructorParameter */
1211  EJBQLConstructorParameter jjtn000 = new EJBQLConstructorParameter(JJTCONSTRUCTORPARAMETER);
1212  boolean jjtc000 = true;
1213  jjtree.openNodeScope(jjtn000);
1214    try {
1215      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1216      case IDENTIFIER:
1217        path();
1218        break;
1219      case AVG:
1220      case MIN:
1221      case MAX:
1222      case SUM:
1223      case COUNT:
1224        aggregate_select_expression();
1225        break;
1226      default:
1227        jj_la1[33] = jj_gen;
1228        jj_consume_token(-1);
1229        throw new ParseException();
1230      }
1231    } catch (Throwable JavaDoc jjte000) {
1232          if (jjtc000) {
1233            jjtree.clearNodeScope(jjtn000);
1234            jjtc000 = false;
1235          } else {
1236            jjtree.popNode();
1237          }
1238          if (jjte000 instanceof RuntimeException JavaDoc) {
1239            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1240          }
1241          if (jjte000 instanceof ParseException) {
1242            {if (true) throw (ParseException)jjte000;}
1243          }
1244          {if (true) throw (Error JavaDoc)jjte000;}
1245    } finally {
1246          if (jjtc000) {
1247            jjtree.closeNodeScope(jjtn000, true);
1248          }
1249    }
1250  }
1251
1252/* rewritten to reduce lookaheads */
1253  final public void aggregate_select_expression() throws ParseException {
1254                                                 /*@bgen(jjtree) Aggregate */
1255  EJBQLAggregate jjtn000 = new EJBQLAggregate(JJTAGGREGATE);
1256  boolean jjtc000 = true;
1257  jjtree.openNodeScope(jjtn000);
1258    try {
1259      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1260      case AVG:
1261        avg();
1262        break;
1263      case MAX:
1264        max();
1265        break;
1266      case MIN:
1267        min();
1268        break;
1269      case SUM:
1270        sum();
1271        break;
1272      case COUNT:
1273        count();
1274        break;
1275      default:
1276        jj_la1[34] = jj_gen;
1277        jj_consume_token(-1);
1278        throw new ParseException();
1279      }
1280    } catch (Throwable JavaDoc jjte000) {
1281          if (jjtc000) {
1282            jjtree.clearNodeScope(jjtn000);
1283            jjtc000 = false;
1284          } else {
1285            jjtree.popNode();
1286          }
1287          if (jjte000 instanceof RuntimeException JavaDoc) {
1288            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1289          }
1290          if (jjte000 instanceof ParseException) {
1291            {if (true) throw (ParseException)jjte000;}
1292          }
1293          {if (true) throw (Error JavaDoc)jjte000;}
1294    } finally {
1295          if (jjtc000) {
1296            jjtree.closeNodeScope(jjtn000, true);
1297          }
1298    }
1299  }
1300
1301  final public void distinct() throws ParseException {
1302                             /*@bgen(jjtree) Distinct */
1303  EJBQLDistinct jjtn000 = new EJBQLDistinct(JJTDISTINCT);
1304  boolean jjtc000 = true;
1305  jjtree.openNodeScope(jjtn000);
1306    try {
1307      jj_consume_token(DISTINCT);
1308    } finally {
1309          if (jjtc000) {
1310            jjtree.closeNodeScope(jjtn000, true);
1311          }
1312    }
1313  }
1314
1315  final public void aggregate_path() throws ParseException {
1316    jj_consume_token(84);
1317    if (jj_2_17(2147483647)) {
1318      arithmetic_expression();
1319    } else if (jj_2_18(2147483647)) {
1320      distinct_path();
1321    } else if (jj_2_19(2147483647)) {
1322      path();
1323    } else if (jj_2_20(2147483647)) {
1324      identification_variable();
1325    } else {
1326      jj_consume_token(-1);
1327      throw new ParseException();
1328    }
1329    jj_consume_token(85);
1330  }
1331
1332  final public void distinct_path() throws ParseException {
1333                                  /*@bgen(jjtree) Distinct */
1334  EJBQLDistinct jjtn000 = new EJBQLDistinct(JJTDISTINCT);
1335  boolean jjtc000 = true;
1336  jjtree.openNodeScope(jjtn000);
1337    try {
1338      jj_consume_token(DISTINCT);
1339      if (jj_2_21(2147483647)) {
1340        path();
1341      } else {
1342        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1343        case IDENTIFIER:
1344          identification_variable();
1345          break;
1346        default:
1347          jj_la1[35] = jj_gen;
1348          jj_consume_token(-1);
1349          throw new ParseException();
1350        }
1351      }
1352    } catch (Throwable JavaDoc jjte000) {
1353          if (jjtc000) {
1354            jjtree.clearNodeScope(jjtn000);
1355            jjtc000 = false;
1356          } else {
1357            jjtree.popNode();
1358          }
1359          if (jjte000 instanceof RuntimeException JavaDoc) {
1360            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1361          }
1362          if (jjte000 instanceof ParseException) {
1363            {if (true) throw (ParseException)jjte000;}
1364          }
1365          {if (true) throw (Error JavaDoc)jjte000;}
1366    } finally {
1367          if (jjtc000) {
1368            jjtree.closeNodeScope(jjtn000, true);
1369          }
1370    }
1371  }
1372
1373  final public void count() throws ParseException {
1374                       /*@bgen(jjtree) Count */
1375  EJBQLCount jjtn000 = new EJBQLCount(JJTCOUNT);
1376  boolean jjtc000 = true;
1377  jjtree.openNodeScope(jjtn000);
1378    try {
1379      jj_consume_token(COUNT);
1380      aggregate_path();
1381    } catch (Throwable JavaDoc jjte000) {
1382          if (jjtc000) {
1383            jjtree.clearNodeScope(jjtn000);
1384            jjtc000 = false;
1385          } else {
1386            jjtree.popNode();
1387          }
1388          if (jjte000 instanceof RuntimeException JavaDoc) {
1389            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1390          }
1391          if (jjte000 instanceof ParseException) {
1392            {if (true) throw (ParseException)jjte000;}
1393          }
1394          {if (true) throw (Error JavaDoc)jjte000;}
1395    } finally {
1396          if (jjtc000) {
1397            jjtree.closeNodeScope(jjtn000, true);
1398          }
1399    }
1400  }
1401
1402  final public void avg() throws ParseException {
1403                       /*@bgen(jjtree) Average */
1404  EJBQLAverage jjtn000 = new EJBQLAverage(JJTAVERAGE);
1405  boolean jjtc000 = true;
1406  jjtree.openNodeScope(jjtn000);
1407    try {
1408      jj_consume_token(AVG);
1409      aggregate_path();
1410    } catch (Throwable JavaDoc jjte000) {
1411          if (jjtc000) {
1412            jjtree.clearNodeScope(jjtn000);
1413            jjtc000 = false;
1414          } else {
1415            jjtree.popNode();
1416          }
1417          if (jjte000 instanceof RuntimeException JavaDoc) {
1418            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1419          }
1420          if (jjte000 instanceof ParseException) {
1421            {if (true) throw (ParseException)jjte000;}
1422          }
1423          {if (true) throw (Error JavaDoc)jjte000;}
1424    } finally {
1425          if (jjtc000) {
1426            jjtree.closeNodeScope(jjtn000, true);
1427          }
1428    }
1429  }
1430
1431  final public void max() throws ParseException {
1432                   /*@bgen(jjtree) Max */
1433  EJBQLMax jjtn000 = new EJBQLMax(JJTMAX);
1434  boolean jjtc000 = true;
1435  jjtree.openNodeScope(jjtn000);
1436    try {
1437      jj_consume_token(MAX);
1438      aggregate_path();
1439    } catch (Throwable JavaDoc jjte000) {
1440          if (jjtc000) {
1441            jjtree.clearNodeScope(jjtn000);
1442            jjtc000 = false;
1443          } else {
1444            jjtree.popNode();
1445          }
1446          if (jjte000 instanceof RuntimeException JavaDoc) {
1447            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1448          }
1449          if (jjte000 instanceof ParseException) {
1450            {if (true) throw (ParseException)jjte000;}
1451          }
1452          {if (true) throw (Error JavaDoc)jjte000;}
1453    } finally {
1454          if (jjtc000) {
1455            jjtree.closeNodeScope(jjtn000, true);
1456          }
1457    }
1458  }
1459
1460  final public void min() throws ParseException {
1461                   /*@bgen(jjtree) Min */
1462  EJBQLMin jjtn000 = new EJBQLMin(JJTMIN);
1463  boolean jjtc000 = true;
1464  jjtree.openNodeScope(jjtn000);
1465    try {
1466      jj_consume_token(MIN);
1467      aggregate_path();
1468    } catch (Throwable JavaDoc jjte000) {
1469          if (jjtc000) {
1470            jjtree.clearNodeScope(jjtn000);
1471            jjtc000 = false;
1472          } else {
1473            jjtree.popNode();
1474          }
1475          if (jjte000 instanceof RuntimeException JavaDoc) {
1476            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1477          }
1478          if (jjte000 instanceof ParseException) {
1479            {if (true) throw (ParseException)jjte000;}
1480          }
1481          {if (true) throw (Error JavaDoc)jjte000;}
1482    } finally {
1483          if (jjtc000) {
1484            jjtree.closeNodeScope(jjtn000, true);
1485          }
1486    }
1487  }
1488
1489  final public void sum() throws ParseException {
1490                   /*@bgen(jjtree) Sum */
1491  EJBQLSum jjtn000 = new EJBQLSum(JJTSUM);
1492  boolean jjtc000 = true;
1493  jjtree.openNodeScope(jjtn000);
1494    try {
1495      jj_consume_token(SUM);
1496      aggregate_path();
1497    } catch (Throwable JavaDoc jjte000) {
1498          if (jjtc000) {
1499            jjtree.clearNodeScope(jjtn000);
1500            jjtc000 = false;
1501          } else {
1502            jjtree.popNode();
1503          }
1504          if (jjte000 instanceof RuntimeException JavaDoc) {
1505            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1506          }
1507          if (jjte000 instanceof ParseException) {
1508            {if (true) throw (ParseException)jjte000;}
1509          }
1510          {if (true) throw (Error JavaDoc)jjte000;}
1511    } finally {
1512          if (jjtc000) {
1513            jjtree.closeNodeScope(jjtn000, true);
1514          }
1515    }
1516  }
1517
1518  final public void where_clause() throws ParseException {
1519                              /*@bgen(jjtree) Where */
1520  EJBQLWhere jjtn000 = new EJBQLWhere(JJTWHERE);
1521  boolean jjtc000 = true;
1522  jjtree.openNodeScope(jjtn000);
1523    try {
1524      jj_consume_token(WHERE);
1525      conditional_expression();
1526    } catch (Throwable JavaDoc jjte000) {
1527          if (jjtc000) {
1528            jjtree.clearNodeScope(jjtn000);
1529            jjtc000 = false;
1530          } else {
1531            jjtree.popNode();
1532          }
1533          if (jjte000 instanceof RuntimeException JavaDoc) {
1534            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1535          }
1536          if (jjte000 instanceof ParseException) {
1537            {if (true) throw (ParseException)jjte000;}
1538          }
1539          {if (true) throw (Error JavaDoc)jjte000;}
1540    } finally {
1541          if (jjtc000) {
1542            jjtree.closeNodeScope(jjtn000, true);
1543          }
1544    }
1545  }
1546
1547  final public void groupby_clause() throws ParseException {
1548                                  /*@bgen(jjtree) GroupBy */
1549  EJBQLGroupBy jjtn000 = new EJBQLGroupBy(JJTGROUPBY);
1550  boolean jjtc000 = true;
1551  jjtree.openNodeScope(jjtn000);
1552    try {
1553      jj_consume_token(GROUP);
1554      jj_consume_token(BY);
1555      groupby_item();
1556      label_10:
1557      while (true) {
1558        if (jj_2_22(2)) {
1559          ;
1560        } else {
1561          break label_10;
1562        }
1563        jj_consume_token(COMMA);
1564        groupby_item();
1565      }
1566    } catch (Throwable JavaDoc jjte000) {
1567          if (jjtc000) {
1568            jjtree.clearNodeScope(jjtn000);
1569            jjtc000 = false;
1570          } else {
1571            jjtree.popNode();
1572          }
1573          if (jjte000 instanceof RuntimeException JavaDoc) {
1574            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1575          }
1576          if (jjte000 instanceof ParseException) {
1577            {if (true) throw (ParseException)jjte000;}
1578          }
1579          {if (true) throw (Error JavaDoc)jjte000;}
1580    } finally {
1581          if (jjtc000) {
1582            jjtree.closeNodeScope(jjtn000, true);
1583          }
1584    }
1585  }
1586
1587  final public void groupby_item() throws ParseException {
1588    if (jj_2_23(2147483647)) {
1589      path();
1590    } else {
1591      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1592      case IDENTIFIER:
1593        identification_variable();
1594        break;
1595      default:
1596        jj_la1[36] = jj_gen;
1597        jj_consume_token(-1);
1598        throw new ParseException();
1599      }
1600    }
1601  }
1602
1603  final public void having_clause() throws ParseException {
1604                                /*@bgen(jjtree) Having */
1605  EJBQLHaving jjtn000 = new EJBQLHaving(JJTHAVING);
1606  boolean jjtc000 = true;
1607  jjtree.openNodeScope(jjtn000);
1608    try {
1609      jj_consume_token(HAVING);
1610      conditional_expression();
1611    } catch (Throwable JavaDoc jjte000) {
1612          if (jjtc000) {
1613            jjtree.clearNodeScope(jjtn000);
1614            jjtc000 = false;
1615          } else {
1616            jjtree.popNode();
1617          }
1618          if (jjte000 instanceof RuntimeException JavaDoc) {
1619            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1620          }
1621          if (jjte000 instanceof ParseException) {
1622            {if (true) throw (ParseException)jjte000;}
1623          }
1624          {if (true) throw (Error JavaDoc)jjte000;}
1625    } finally {
1626          if (jjtc000) {
1627            jjtree.closeNodeScope(jjtn000, true);
1628          }
1629    }
1630  }
1631
1632  final public void subquery() throws ParseException {
1633                              /*@bgen(jjtree) Subselect */
1634  EJBQLSubselect jjtn000 = new EJBQLSubselect(JJTSUBSELECT);
1635  boolean jjtc000 = true;
1636  jjtree.openNodeScope(jjtn000);
1637    try {
1638      simple_select_clause();
1639      subquery_from_clause();
1640      if (jj_2_24(2147483647)) {
1641        where_clause();
1642      } else {
1643        ;
1644      }
1645      if (jj_2_25(2147483647)) {
1646        groupby_clause();
1647      } else {
1648        ;
1649      }
1650      if (jj_2_26(2147483647)) {
1651        having_clause();
1652      } else {
1653        ;
1654      }
1655    } catch (Throwable JavaDoc jjte000) {
1656          if (jjtc000) {
1657            jjtree.clearNodeScope(jjtn000);
1658            jjtc000 = false;
1659          } else {
1660            jjtree.popNode();
1661          }
1662          if (jjte000 instanceof RuntimeException JavaDoc) {
1663            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1664          }
1665          if (jjte000 instanceof ParseException) {
1666            {if (true) throw (ParseException)jjte000;}
1667          }
1668          {if (true) throw (Error JavaDoc)jjte000;}
1669    } finally {
1670          if (jjtc000) {
1671            jjtree.closeNodeScope(jjtn000, true);
1672          }
1673    }
1674  }
1675
1676/* changed to eliminate left recursion */
1677  final public void conditional_expression() throws ParseException {
1678    conditional_term();
1679    label_11:
1680    while (true) {
1681      if (jj_2_27(2)) {
1682        ;
1683      } else {
1684        break label_11;
1685      }
1686      jj_consume_token(OR);
1687                                                 EJBQLOr jjtn001 = new EJBQLOr(JJTOR);
1688                                                 boolean jjtc001 = true;
1689                                                 jjtree.openNodeScope(jjtn001);
1690      try {
1691        conditional_expression();
1692      } catch (Throwable JavaDoc jjte001) {
1693                                                 if (jjtc001) {
1694                                                   jjtree.clearNodeScope(jjtn001);
1695                                                   jjtc001 = false;
1696                                                 } else {
1697                                                   jjtree.popNode();
1698                                                 }
1699                                                 if (jjte001 instanceof RuntimeException JavaDoc) {
1700                                                   {if (true) throw (RuntimeException JavaDoc)jjte001;}
1701                                                 }
1702                                                 if (jjte001 instanceof ParseException) {
1703                                                   {if (true) throw (ParseException)jjte001;}
1704                                                 }
1705                                                 {if (true) throw (Error JavaDoc)jjte001;}
1706      } finally {
1707                                                 if (jjtc001) {
1708                                                   jjtree.closeNodeScope(jjtn001, 2);
1709                                                 }
1710      }
1711    }
1712  }
1713
1714/* changed to eliminate left recursion */
1715  final public void conditional_term() throws ParseException {
1716    conditional_factor();
1717    label_12:
1718    while (true) {
1719      if (jj_2_28(2)) {
1720        ;
1721      } else {
1722        break label_12;
1723      }
1724      jj_consume_token(AND);
1725                                                    EJBQLAnd jjtn001 = new EJBQLAnd(JJTAND);
1726                                                    boolean jjtc001 = true;
1727                                                    jjtree.openNodeScope(jjtn001);
1728      try {
1729        conditional_term();
1730      } catch (Throwable JavaDoc jjte001) {
1731                                                    if (jjtc001) {
1732                                                      jjtree.clearNodeScope(jjtn001);
1733                                                      jjtc001 = false;
1734                                                    } else {
1735                                                      jjtree.popNode();
1736                                                    }
1737                                                    if (jjte001 instanceof RuntimeException JavaDoc) {
1738                                                      {if (true) throw (RuntimeException JavaDoc)jjte001;}
1739                                                    }
1740                                                    if (jjte001 instanceof ParseException) {
1741                                                      {if (true) throw (ParseException)jjte001;}
1742                                                    }
1743                                                    {if (true) throw (Error JavaDoc)jjte001;}
1744      } finally {
1745                                                    if (jjtc001) {
1746                                                      jjtree.closeNodeScope(jjtn001, 2);
1747                                                    }
1748      }
1749    }
1750  }
1751
1752  final public void conditional_factor() throws ParseException {
1753    if (jj_2_29(2147483647)) {
1754      jj_consume_token(NOT);
1755                 EJBQLNot jjtn001 = new EJBQLNot(JJTNOT);
1756                 boolean jjtc001 = true;
1757                 jjtree.openNodeScope(jjtn001);
1758      try {
1759        conditional_primary();
1760      } catch (Throwable JavaDoc jjte001) {
1761                 if (jjtc001) {
1762                   jjtree.clearNodeScope(jjtn001);
1763                   jjtc001 = false;
1764                 } else {
1765                   jjtree.popNode();
1766                 }
1767                 if (jjte001 instanceof RuntimeException JavaDoc) {
1768                   {if (true) throw (RuntimeException JavaDoc)jjte001;}
1769                 }
1770                 if (jjte001 instanceof ParseException) {
1771                   {if (true) throw (ParseException)jjte001;}
1772                 }
1773                 {if (true) throw (Error JavaDoc)jjte001;}
1774      } finally {
1775                 if (jjtc001) {
1776                   jjtree.closeNodeScope(jjtn001, true);
1777                 }
1778      }
1779    } else {
1780      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1781      case PLUS:
1782      case MINUS:
1783      case NEW:
1784      case ALL:
1785      case ANY:
1786      case EXISTS:
1787      case SOME:
1788      case EMPTY:
1789      case ASC:
1790      case DESC:
1791      case ORDER:
1792      case BY:
1793      case IS:
1794      case MEMBER:
1795      case OF:
1796      case LIKE:
1797      case ESCAPE:
1798      case BETWEEN:
1799      case NULL:
1800      case AVG:
1801      case MIN:
1802      case MAX:
1803      case SUM:
1804      case COUNT:
1805      case OR:
1806      case AND:
1807      case NOT:
1808      case CONCAT:
1809      case SUBSTRING:
1810      case TRIM:
1811      case LOWER:
1812      case UPPER:
1813      case LEADING:
1814      case TRAILING:
1815      case BOTH:
1816      case LENGTH:
1817      case LOCATE:
1818      case ABS:
1819      case SQRT:
1820      case MOD:
1821      case SIZE:
1822      case CURRENT_DATE:
1823      case CURRENT_TIME:
1824      case CURRENT_TIMESTAMP:
1825      case SELECT:
1826      case DISTINCT:
1827      case FROM:
1828      case UPDATE:
1829      case DELETE:
1830      case WHERE:
1831      case GROUP:
1832      case HAVING:
1833      case AS:
1834      case LEFT:
1835      case OUTER:
1836      case INNER:
1837      case JOIN:
1838      case FETCH:
1839      case IN:
1840      case SET:
1841      case OBJECT:
1842      case INTEGER_LITERAL:
1843      case DECIMAL_LITERAL:
1844      case BOOLEAN_LITERAL:
1845      case STRING_LITERAL:
1846      case IDENTIFIER:
1847      case 84:
1848      case 86:
1849      case 87:
1850        conditional_primary();
1851        break;
1852      default:
1853        jj_la1[37] = jj_gen;
1854        jj_consume_token(-1);
1855        throw new ParseException();
1856      }
1857    }
1858  }
1859
1860  final public void conditional_primary() throws ParseException {
1861    if (jj_2_30(2147483647)) {
1862      simple_cond_expression();
1863    } else {
1864      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1865      case 84:
1866        jj_consume_token(84);
1867        conditional_expression();
1868        jj_consume_token(85);
1869        break;
1870      default:
1871        jj_la1[38] = jj_gen;
1872        jj_consume_token(-1);
1873        throw new ParseException();
1874      }
1875    }
1876  }
1877
1878  final public void simple_cond_expression() throws ParseException {
1879    if (jj_2_31(2147483647)) {
1880      exists_expression();
1881    } else if (jj_2_32(2147483647)) {
1882      comparison_expression();
1883    } else if (jj_2_33(2147483647)) {
1884      between_expression();
1885    } else if (jj_2_34(2147483647)) {
1886      like_expression();
1887    } else if (jj_2_35(2147483647)) {
1888      in_expression();
1889    } else if (jj_2_36(2147483647)) {
1890      null_comparison_expression();
1891    } else if (jj_2_37(2147483647)) {
1892      empty_collection_comparison_expression();
1893    } else if (jj_2_38(2147483647)) {
1894      collection_member_expression();
1895    } else {
1896      jj_consume_token(-1);
1897      throw new ParseException();
1898    }
1899  }
1900
1901  final public void between_expression() throws ParseException {
1902                                      /*@bgen(jjtree) Between */
1903  EJBQLBetween jjtn000 = new EJBQLBetween(JJTBETWEEN);
1904  boolean jjtc000 = true;
1905  jjtree.openNodeScope(jjtn000);
1906    try {
1907      if (jj_2_39(6)) {
1908        arithmetic_expression();
1909        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1910        case NOT:
1911          jj_consume_token(NOT);
1912                         jjtn000.not = true;
1913          break;
1914        default:
1915          jj_la1[39] = jj_gen;
1916          ;
1917        }
1918        jj_consume_token(BETWEEN);
1919        arithmetic_expression();
1920        jj_consume_token(AND);
1921        arithmetic_expression();
1922      } else if (jj_2_40(6)) {
1923        string_expression();
1924        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1925        case NOT:
1926          jj_consume_token(NOT);
1927                         jjtn000.not = true;
1928          break;
1929        default:
1930          jj_la1[40] = jj_gen;
1931          ;
1932        }
1933        jj_consume_token(BETWEEN);
1934        string_expression();
1935        jj_consume_token(AND);
1936        string_expression();
1937      } else if (jj_2_41(6)) {
1938        datetime_expression();
1939        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1940        case NOT:
1941          jj_consume_token(NOT);
1942                         jjtn000.not = true;
1943          break;
1944        default:
1945          jj_la1[41] = jj_gen;
1946          ;
1947        }
1948        jj_consume_token(BETWEEN);
1949        datetime_expression();
1950        jj_consume_token(AND);
1951        datetime_expression();
1952      } else {
1953        jj_consume_token(-1);
1954        throw new ParseException();
1955      }
1956    } catch (Throwable JavaDoc jjte000) {
1957          if (jjtc000) {
1958            jjtree.clearNodeScope(jjtn000);
1959            jjtc000 = false;
1960          } else {
1961            jjtree.popNode();
1962          }
1963          if (jjte000 instanceof RuntimeException JavaDoc) {
1964            {if (true) throw (RuntimeException JavaDoc)jjte000;}
1965          }
1966          if (jjte000 instanceof ParseException) {
1967            {if (true) throw (ParseException)jjte000;}
1968          }
1969          {if (true) throw (Error JavaDoc)jjte000;}
1970    } finally {
1971          if (jjtc000) {
1972            jjtree.closeNodeScope(jjtn000, true);
1973          }
1974    }
1975  }
1976
1977  final public void in_expression() throws ParseException {
1978                            /*@bgen(jjtree) In */
1979  EJBQLIn jjtn000 = new EJBQLIn(JJTIN);
1980  boolean jjtc000 = true;
1981  jjtree.openNodeScope(jjtn000);
1982    try {
1983      path();
1984      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1985      case NOT:
1986        jj_consume_token(NOT);
1987                                      jjtn000.not = true;
1988        break;
1989      default:
1990        jj_la1[42] = jj_gen;
1991        ;
1992      }
1993      jj_consume_token(IN);
1994      jj_consume_token(84);
1995      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1996      case PLUS:
1997      case MINUS:
1998      case INTEGER_LITERAL:
1999      case DECIMAL_LITERAL:
2000      case BOOLEAN_LITERAL:
2001      case STRING_LITERAL:
2002      case 86:
2003      case 87:
2004        literal_or_param();
2005        label_13:
2006        while (true) {
2007          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2008          case COMMA:
2009            ;
2010            break;
2011          default:
2012            jj_la1[43] = jj_gen;
2013            break label_13;
2014          }
2015          jj_consume_token(COMMA);
2016          literal_or_param();
2017        }
2018        break;
2019      case SELECT:
2020        subquery();
2021        break;
2022      default:
2023        jj_la1[44] = jj_gen;
2024        jj_consume_token(-1);
2025        throw new ParseException();
2026      }
2027      jj_consume_token(85);
2028    } catch (Throwable JavaDoc jjte000) {
2029          if (jjtc000) {
2030            jjtree.clearNodeScope(jjtn000);
2031            jjtc000 = false;
2032          } else {
2033            jjtree.popNode();
2034          }
2035          if (jjte000 instanceof RuntimeException JavaDoc) {
2036            {if (true) throw (RuntimeException JavaDoc)jjte000;}
2037          }
2038          if (jjte000 instanceof ParseException) {
2039            {if (true) throw (ParseException)jjte000;}
2040          }
2041          {if (true) throw (Error JavaDoc)jjte000;}
2042    } finally {
2043          if (jjtc000) {
2044            jjtree.closeNodeScope(jjtn000, true);
2045          }
2046    }
2047  }
2048
2049  final public void literal_or_param() throws ParseException {
2050    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2051    case PLUS:
2052    case MINUS:
2053    case INTEGER_LITERAL:
2054    case DECIMAL_LITERAL:
2055      numeric_literal();
2056      break;
2057    case STRING_LITERAL:
2058      string_literal();
2059      break;
2060    case BOOLEAN_LITERAL:
2061      boolean_literal();
2062      break;
2063    case 86:
2064    case 87:
2065      input_parameter();
2066      break;
2067    default:
2068      jj_la1[45] = jj_gen;
2069      jj_consume_token(-1);
2070      throw new ParseException();
2071    }
2072  }
2073
2074  final public void like_expression() throws ParseException {
2075                                /*@bgen(jjtree) Like */
2076  EJBQLLike jjtn000 = new EJBQLLike(JJTLIKE);
2077  boolean jjtc000 = true;
2078  jjtree.openNodeScope(jjtn000);
2079    try {
2080      string_expression();
2081      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2082      case NOT:
2083        jj_consume_token(NOT);
2084                                     jjtn000.not = true;
2085        break;
2086      default:
2087        jj_la1[46] = jj_gen;
2088        ;
2089      }
2090      jj_consume_token(LIKE);
2091      pattern_value();
2092    } catch (Throwable JavaDoc jjte000) {
2093          if (jjtc000) {
2094            jjtree.clearNodeScope(jjtn000);
2095            jjtc000 = false;
2096          } else {
2097            jjtree.popNode();
2098          }
2099          if (jjte000 instanceof RuntimeException JavaDoc) {
2100            {if (true) throw (RuntimeException JavaDoc)jjte000;}
2101          }
2102          if (jjte000 instanceof ParseException) {
2103            {if (true) throw (ParseException)jjte000;}
2104          }
2105          {if (true) throw (Error JavaDoc)jjte000;}
2106    } finally {
2107          if (jjtc000) {
2108            jjtree.closeNodeScope(jjtn000, true);
2109          }
2110    }
2111  }
2112
2113  final public void null_comparison_expression() throws ParseException {
2114                                             /*@bgen(jjtree) IsNull */
2115  EJBQLIsNull jjtn000 = new EJBQLIsNull(JJTISNULL);
2116  boolean jjtc000 = true;
2117  jjtree.openNodeScope(jjtn000);
2118    try {
2119      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2120      case 86:
2121      case 87:
2122        input_parameter();
2123        break;
2124      case IDENTIFIER:
2125        path();
2126        break;
2127      default:
2128        jj_la1[47] = jj_gen;
2129        jj_consume_token(-1);
2130        throw new ParseException();
2131      }
2132      jj_consume_token(IS);
2133      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2134      case NOT:
2135        jj_consume_token(NOT);
2136                      jjtn000.not = true;
2137        break;
2138      default:
2139        jj_la1[48] = jj_gen;
2140        ;
2141      }
2142      jj_consume_token(NULL);
2143    } catch (Throwable JavaDoc jjte000) {
2144          if (jjtc000) {
2145            jjtree.clearNodeScope(jjtn000);
2146            jjtc000 = false;
2147          } else {
2148            jjtree.popNode();
2149          }
2150          if (jjte000 instanceof RuntimeException JavaDoc) {
2151            {if (true) throw (RuntimeException JavaDoc)jjte000;}
2152          }
2153          if (jjte000 instanceof ParseException) {
2154            {if (true) throw (ParseException)jjte000;}
2155          }
2156          {if (true) throw (Error JavaDoc)jjte000;}
2157    } finally {
2158          if (jjtc000) {
2159            jjtree.closeNodeScope(jjtn000, true);
2160          }
2161    }
2162  }
2163
2164  final public void empty_collection_comparison_expression() throws ParseException {
2165                                                          /*@bgen(jjtree) IsEmpty */
2166  EJBQLIsEmpty jjtn000 = new EJBQLIsEmpty(JJTISEMPTY);
2167  boolean jjtc000 = true;
2168  jjtree.openNodeScope(jjtn000);
2169    try {
2170      path();
2171      jj_consume_token(IS);
2172      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2173      case NOT:
2174        jj_consume_token(NOT);
2175                             jjtn000.not = true;
2176        break;
2177      default:
2178        jj_la1[49] = jj_gen;
2179        ;
2180      }
2181      jj_consume_token(EMPTY);
2182    } catch (Throwable JavaDoc jjte000) {
2183          if (jjtc000) {
2184            jjtree.clearNodeScope(jjtn000);
2185            jjtc000 = false;
2186          } else {
2187            jjtree.popNode();
2188          }
2189          if (jjte000 instanceof RuntimeException JavaDoc) {
2190            {if (true) throw (RuntimeException JavaDoc)jjte000;}
2191          }
2192          if (jjte000 instanceof ParseException) {
2193            {if (true) throw (ParseException)jjte000;}
2194          }
2195          {if (true) throw (Error JavaDoc)jjte000;}
2196    } finally {
2197          if (jjtc000) {
2198            jjtree.closeNodeScope(jjtn000, true);
2199          }
2200    }
2201  }
2202
2203  final public void collection_member_expression() throws ParseException {
2204                                                 /*@bgen(jjtree) MemberOf */
2205  EJBQLMemberOf jjtn000 = new EJBQLMemberOf(JJTMEMBEROF);
2206  boolean jjtc000 = true;
2207  jjtree.openNodeScope(jjtn000);
2208    try {
2209      if (jj_2_42(2147483647)) {
2210        path();
2211      } else {
2212        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2213        case 86:
2214        case 87:
2215          input_parameter();
2216          break;
2217        case NEW:
2218        case ALL:
2219        case ANY:
2220        case EXISTS:
2221        case SOME:
2222        case EMPTY:
2223        case ASC:
2224        case DESC:
2225        case ORDER:
2226        case BY:
2227        case IS:
2228        case MEMBER:
2229        case OF:
2230        case LIKE:
2231        case ESCAPE:
2232        case BETWEEN:
2233        case NULL:
2234        case AVG:
2235        case MIN:
2236        case MAX:
2237        case SUM:
2238        case COUNT:
2239        case OR:
2240        case AND:
2241        case NOT:
2242        case CONCAT:
2243        case SUBSTRING:
2244        case TRIM:
2245        case LOWER:
2246        case UPPER:
2247        case LEADING:
2248        case TRAILING:
2249        case BOTH:
2250        case LENGTH:
2251        case LOCATE:
2252        case ABS:
2253        case SQRT:
2254        case MOD:
2255        case SIZE:
2256        case CURRENT_DATE:
2257        case CURRENT_TIME:
2258        case CURRENT_TIMESTAMP:
2259        case SELECT:
2260        case DISTINCT:
2261        case FROM:
2262        case UPDATE:
2263        case DELETE:
2264        case WHERE:
2265        case GROUP:
2266        case HAVING:
2267        case AS:
2268        case LEFT:
2269        case OUTER:
2270        case INNER:
2271        case JOIN:
2272        case FETCH:
2273        case IN:
2274        case SET:
2275        case OBJECT:
2276        case IDENTIFIER:
2277          path_component();
2278          break;
2279        default:
2280          jj_la1[50] = jj_gen;
2281          jj_consume_token(-1);
2282          throw new ParseException();
2283        }
2284      }
2285      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2286      case NOT:
2287        jj_consume_token(NOT);
2288                 jjtn000.not = true;
2289        break;
2290      default:
2291        jj_la1[51] = jj_gen;
2292        ;
2293      }
2294      jj_consume_token(MEMBER);
2295      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2296      case OF:
2297        jj_consume_token(OF);
2298        break;
2299      default:
2300        jj_la1[52] = jj_gen;
2301        ;
2302      }
2303      path();
2304    } catch (Throwable JavaDoc jjte000) {
2305          if (jjtc000) {
2306            jjtree.clearNodeScope(jjtn000);
2307            jjtc000 = false;
2308          } else {
2309            jjtree.popNode();
2310          }
2311          if (jjte000 instanceof RuntimeException JavaDoc) {
2312            {if (true) throw (RuntimeException JavaDoc)jjte000;}
2313          }
2314          if (jjte000 instanceof ParseException) {
2315            {if (true) throw (ParseException)jjte000;}
2316          }
2317          {if (true) throw (Error JavaDoc)jjte000;}
2318    } finally {
2319          if (jjtc000) {
2320            jjtree.closeNodeScope(jjtn000, true);
2321          }
2322    }
2323  }
2324
2325  final public void exists_expression() throws ParseException {
2326                                    /*@bgen(jjtree) Exists */
2327  EJBQLExists jjtn000 = new EJBQLExists(JJTEXISTS);
2328  boolean jjtc000 = true;
2329  jjtree.openNodeScope(jjtn000);
2330    try {
2331      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2332      case NOT:
2333        jj_consume_token(NOT);
2334                 jjtn000.not = true;
2335        break;
2336      default:
2337        jj_la1[53] = jj_gen;
2338        ;
2339      }
2340      jj_consume_token(EXISTS);
2341      jj_consume_token(84);
2342      subquery();
2343      jj_consume_token(85);
2344    } catch (Throwable JavaDoc jjte000) {
2345          if (jjtc000) {
2346            jjtree.clearNodeScope(jjtn000);
2347            jjtc000 = false;
2348          } else {
2349            jjtree.popNode();
2350          }
2351          if (jjte000 instanceof RuntimeException JavaDoc) {
2352            {if (true) throw (RuntimeException JavaDoc)jjte000;}
2353          }
2354          if (jjte000 instanceof ParseException) {
2355            {if (true) throw (ParseException)jjte000;}
2356          }
2357          {if (true) throw (Error JavaDoc)jjte000;}
2358    } finally {
2359          if (jjtc000) {
2360            jjtree.closeNodeScope(jjtn000, true);
2361          }
2362    }
2363  }
2364
2365  final public void all_or_any_expression() throws ParseException {
2366    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2367    case ANY:
2368      any_expression();
2369      break;
2370    case SOME:
2371      some_expression();
2372      break;
2373    case ALL:
2374      all_expression();
2375      break;
2376    default:
2377      jj_la1[54] = jj_gen;
2378      jj_consume_token(-1);
2379      throw new ParseException();
2380    }
2381  }
2382
2383  final public void any_expression() throws ParseException {
2384                              /*@bgen(jjtree) Any */
2385  EJBQLAny jjtn000 = new EJBQLAny(JJTANY);
2386  boolean jjtc000 = true;
2387  jjtree.openNodeScope(jjtn000);
2388    try {
2389      jj_consume_token(ANY);
2390      jj_consume_token(84);
2391      subquery();
2392      jj_consume_token(85);
2393    } catch (Throwable JavaDoc jjte000) {
2394          if (jjtc000) {
2395            jjtree.clearNodeScope(jjtn000);
2396            jjtc000 = false;
2397          } else {
2398            jjtree.popNode();
2399          }
2400          if (jjte000 instanceof RuntimeException JavaDoc) {
2401            {if (true) throw (RuntimeException JavaDoc)jjte000;}
2402          }
2403          if (jjte000 instanceof ParseException) {
2404            {if (true) throw (ParseException)jjte000;}
2405          }
2406          {if (true) throw (Error JavaDoc)jjte000;}
2407    } finally {
2408          if (jjtc000) {
2409            jjtree.closeNodeScope(jjtn000, true);
2410          }
2411    }
2412  }
2413
2414  final public void some_expression() throws ParseException {
2415                               /*@bgen(jjtree) Any */
2416  EJBQLAny jjtn000 = new EJBQLAny(JJTANY);
2417  boolean jjtc000 = true;
2418  jjtree.openNodeScope(jjtn000);
2419    try {
2420      jj_consume_token(SOME);
2421      jj_consume_token(84);
2422      subquery();
2423      jj_consume_token(85);
2424    } catch (Throwable JavaDoc jjte000) {
2425          if (jjtc000) {
2426            jjtree.clearNodeScope(jjtn000);
2427            jjtc000 = false;
2428          } else {
2429            jjtree.popNode();
2430          }
2431          if (jjte000 instanceof RuntimeException JavaDoc) {
2432            {if (true) throw (RuntimeException JavaDoc)jjte000;}
2433          }
2434          if (jjte000 instanceof ParseException) {
2435            {if (true) throw (ParseException)jjte000;}
2436          }
2437          {if (true) throw (Error JavaDoc)jjte000;}
2438    } finally {
2439          if (jjtc000) {
2440            jjtree.closeNodeScope(jjtn000, true);
2441          }
2442    }
2443  }
2444
2445  final public void all_expression() throws ParseException {
2446                              /*@bgen(jjtree) All */
2447  EJBQLAll jjtn000 = new EJBQLAll(JJTALL);
2448  boolean jjtc000 = true;
2449  jjtree.openNodeScope(jjtn000);
2450    try {
2451      jj_consume_token(ALL);
2452      jj_consume_token(84);
2453      subquery();
2454      jj_consume_token(85);
2455    } catch (Throwable JavaDoc jjte000) {
2456          if (jjtc000) {
2457            jjtree.clearNodeScope(jjtn000);
2458            jjtc000 = false;
2459          } else {
2460            jjtree.popNode();
2461          }
2462          if (jjte000 instanceof RuntimeException JavaDoc) {
2463            {if (true) throw (RuntimeException JavaDoc)jjte000;}
2464          }
2465          if (jjte000 instanceof ParseException) {
2466            {if (true) throw (ParseException)jjte000;}
2467          }
2468          {if (true) throw (Error JavaDoc)jjte000;}
2469    } finally {
2470          if (jjtc000) {
2471            jjtree.closeNodeScope(jjtn000, true);
2472          }
2473    }
2474  }
2475
2476  final public void comparison_expression() throws ParseException {
2477    if (jj_2_43(2147483647)) {
2478      arithmetic_comp();
2479    } else if (jj_2_44(2147483647)) {
2480      string_comp();
2481    } else if (jj_2_45(2147483647)) {
2482      boolean_comp();
2483    } else if (jj_2_46(2147483647)) {
2484      enum_comp();
2485    } else if (jj_2_47(2147483647)) {
2486      datetime_comp();
2487    } else if (jj_2_48(2147483647)) {
2488      entity_comp();
2489    } else {
2490      jj_consume_token(-1);
2491      throw new ParseException();
2492    }
2493  }
2494
2495  final public void string_comp() throws ParseException {
2496    string_expression();
2497    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2498    case EQ:
2499      jj_consume_token(EQ);
2500                        EJBQLEquals jjtn001 = new EJBQLEquals(JJTEQUALS);
2501                        boolean jjtc001 = true;
2502                        jjtree.openNodeScope(jjtn001);
2503      try {
2504        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2505        case CONCAT:
2506        case SUBSTRING:
2507        case TRIM:
2508        case LOWER:
2509        case UPPER:
2510        case STRING_LITERAL:
2511        case IDENTIFIER:
2512        case 84:
2513        case 86:
2514        case 87:
2515          string_expression();
2516          break;
2517        case ALL:
2518        case ANY:
2519        case SOME:
2520          all_or_any_expression();
2521          break;
2522        default:
2523          jj_la1[55] = jj_gen;
2524          jj_consume_token(-1);
2525          throw new ParseException();
2526        }
2527      } catch (Throwable JavaDoc jjte001) {
2528                        if (jjtc001) {
2529                          jjtree.clearNodeScope(jjtn001);
2530                          jjtc001 = false;
2531                        } else {
2532                          jjtree.popNode();
2533                        }
2534                        if (jjte001 instanceof RuntimeException JavaDoc) {
2535                          {if (true) throw (RuntimeException JavaDoc)jjte001;}
2536                        }
2537                        if (jjte001 instanceof ParseException) {
2538                          {if (true) throw (ParseException)jjte001;}
2539                        }
2540                        {if (true) throw (Error JavaDoc)jjte001;}
2541      } finally {
2542                        if (jjtc001) {
2543                          jjtree.closeNodeScope(jjtn001, 2);
2544                        }
2545      }
2546      break;
2547    case NE:
2548      jj_consume_token(NE);
2549                          EJBQLNotEquals jjtn002 = new EJBQLNotEquals(JJTNOTEQUALS);
2550                          boolean jjtc002 = true;
2551                          jjtree.openNodeScope(jjtn002);
2552      try {
2553        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2554        case CONCAT:
2555        case SUBSTRING:
2556        case TRIM:
2557        case LOWER:
2558        case UPPER:
2559        case STRING_LITERAL:
2560        case IDENTIFIER:
2561        case 84:
2562        case 86:
2563        case 87:
2564          string_expression();
2565          break;
2566        case ALL:
2567        case ANY:
2568        case SOME:
2569          all_or_any_expression();
2570          break;
2571        default:
2572          jj_la1[56] = jj_gen;
2573          jj_consume_token(-1);
2574          throw new ParseException();
2575        }
2576      } catch (Throwable JavaDoc jjte002) {
2577                          if (jjtc002) {
2578                            jjtree.clearNodeScope(jjtn002);
2579                            jjtc002 = false;
2580                          } else {
2581                            jjtree.popNode();
2582                          }
2583                          if (jjte002 instanceof RuntimeException JavaDoc) {
2584                            {if (true) throw (RuntimeException JavaDoc)jjte002;}
2585                          }
2586                          if (jjte002 instanceof ParseException) {
2587                            {if (true) throw (ParseException)jjte002;}
2588                          }
2589                          {if (true) throw (Error JavaDoc)jjte002;}
2590      } finally {
2591                          if (jjtc002) {
2592                            jjtree.closeNodeScope(jjtn002, 2);
2593                          }
2594      }
2595      break;
2596    case GT:
2597      jj_consume_token(GT);
2598                          EJBQLGreaterThan jjtn003 = new EJBQLGreaterThan(JJTGREATERTHAN);
2599                          boolean jjtc003 = true;
2600                          jjtree.openNodeScope(jjtn003);
2601      try {
2602        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2603        case CONCAT:
2604        case SUBSTRING:
2605        case TRIM:
2606        case LOWER:
2607        case UPPER:
2608        case STRING_LITERAL:
2609        case IDENTIFIER:
2610        case 84:
2611        case 86:
2612        case 87:
2613          string_expression();
2614          break;
2615        case ALL:
2616        case ANY:
2617        case SOME:
2618          all_or_any_expression();
2619          break;
2620        default:
2621          jj_la1[57] = jj_gen;
2622          jj_consume_token(-1);
2623          throw new ParseException();
2624        }
2625      } catch (Throwable JavaDoc jjte003) {
2626                          if (jjtc003) {
2627                            jjtree.clearNodeScope(jjtn003);
2628                            jjtc003 = false;
2629                          } else {
2630                            jjtree.popNode();
2631                          }
2632                          if (jjte003 instanceof RuntimeException JavaDoc) {
2633                            {if (true) throw (RuntimeException JavaDoc)jjte003;}
2634                          }
2635                          if (jjte003 instanceof ParseException) {
2636                            {if (true) throw (ParseException)jjte003;}
2637                          }
2638                          {if (true) throw (Error JavaDoc)jjte003;}
2639      } finally {
2640                          if (jjtc003) {
2641                            jjtree.closeNodeScope(jjtn003, 2);
2642                          }
2643      }
2644      break;
2645    case GE:
2646      jj_consume_token(GE);
2647                          EJBQLGreaterOrEqual jjtn004 = new EJBQLGreaterOrEqual(JJTGREATEROREQUAL);
2648                          boolean jjtc004 = true;
2649                          jjtree.openNodeScope(jjtn004);
2650      try {
2651        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2652        case CONCAT:
2653        case SUBSTRING:
2654        case TRIM:
2655        case LOWER:
2656        case UPPER:
2657        case STRING_LITERAL:
2658        case IDENTIFIER:
2659        case 84:
2660        case 86:
2661        case 87:
2662          string_expression();
2663          break;
2664        case ALL:
2665        case ANY:
2666        case SOME:
2667          all_or_any_expression();
2668          break;
2669        default:
2670          jj_la1[58] = jj_gen;
2671          jj_consume_token(-1);
2672          throw new ParseException();
2673        }
2674      } catch (Throwable JavaDoc jjte004) {
2675                          if (jjtc004) {
2676                            jjtree.clearNodeScope(jjtn004);
2677                            jjtc004 = false;
2678                          } else {
2679                            jjtree.popNode();
2680                          }
2681                          if (jjte004 instanceof RuntimeException JavaDoc) {
2682                            {if (true) throw (RuntimeException JavaDoc)jjte004;}
2683                          }
2684                          if (jjte004 instanceof ParseException) {
2685                            {if (true) throw (ParseException)jjte004;}
2686                          }
2687                          {if (true) throw (Error JavaDoc)jjte004;}
2688      } finally {
2689                          if (jjtc004) {
2690                            jjtree.closeNodeScope(jjtn004, 2);
2691                          }
2692      }
2693      break;
2694    case LT:
2695      jj_consume_token(LT);
2696                          EJBQLLessThan jjtn005 = new EJBQLLessThan(JJTLESSTHAN);
2697                          boolean jjtc005 = true;
2698                          jjtree.openNodeScope(jjtn005);
2699      try {
2700        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2701        case CONCAT:
2702        case SUBSTRING:
2703        case TRIM:
2704        case LOWER:
2705        case UPPER:
2706        case STRING_LITERAL:
2707        case IDENTIFIER:
2708        case 84:
2709        case 86:
2710        case 87:
2711          string_expression();
2712          break;
2713        case ALL:
2714        case ANY:
2715        case SOME:
2716          all_or_any_expression();
2717          break;
2718        default:
2719          jj_la1[59] = jj_gen;
2720          jj_consume_token(-1);
2721          throw new ParseException();
2722        }
2723      } catch (Throwable JavaDoc jjte005) {
2724                          if (jjtc005) {
2725                            jjtree.clearNodeScope(jjtn005);
2726                            jjtc005 = false;
2727                          } else {
2728                            jjtree.popNode();
2729                          }
2730                          if (jjte005 instanceof RuntimeException JavaDoc) {
2731                            {if (true) throw (RuntimeException JavaDoc)jjte005;}
2732                          }
2733                          if (jjte005 instanceof ParseException) {
2734                            {if (true) throw (ParseException)jjte005;}
2735                          }
2736                          {if (true) throw (Error JavaDoc)jjte005;}
2737      } finally {
2738                          if (jjtc005) {
2739                            jjtree.closeNodeScope(jjtn005, 2);
2740                          }
2741      }
2742      break;
2743    case LE:
2744      jj_consume_token(LE);
2745                          EJBQLLessOrEqual jjtn006 = new EJBQLLessOrEqual(JJTLESSOREQUAL);
2746                          boolean jjtc006 = true;
2747                          jjtree.openNodeScope(jjtn006);
2748      try {
2749        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2750        case CONCAT:
2751        case SUBSTRING:
2752        case TRIM:
2753        case LOWER:
2754        case UPPER:
2755        case STRING_LITERAL:
2756        case IDENTIFIER:
2757        case 84:
2758        case 86:
2759        case 87:
2760          string_expression();
2761          break;
2762        case ALL:
2763        case ANY:
2764        case SOME:
2765          all_or_any_expression();
2766          break;
2767        default:
2768          jj_la1[60] = jj_gen;
2769          jj_consume_token(-1);
2770          throw new ParseException();
2771        }
2772      } catch (Throwable JavaDoc jjte006) {
2773                          if (jjtc006) {
2774                            jjtree.clearNodeScope(jjtn006);
2775                            jjtc006 = false;
2776                          } else {
2777                            jjtree.popNode();
2778                          }
2779                          if (jjte006 instanceof RuntimeException JavaDoc) {
2780                            {if (true) throw (RuntimeException JavaDoc)jjte006;}
2781                          }
2782                          if (jjte006 instanceof ParseException) {
2783                            {if (true) throw (ParseException)jjte006;}
2784                          }
2785                          {if (true) throw (Error JavaDoc)jjte006;}
2786      } finally {
2787                          if (jjtc006) {
2788                            jjtree.closeNodeScope(jjtn006, 2);
2789                          }
2790      }
2791      break;
2792    default:
2793      jj_la1[61] = jj_gen;
2794      jj_consume_token(-1);
2795      throw new ParseException();
2796    }
2797  }
2798
2799  final public void boolean_comp() throws ParseException {
2800    boolean_expression();
2801    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2802    case EQ:
2803      jj_consume_token(EQ);
2804                EJBQLEquals jjtn001 = new EJBQLEquals(JJTEQUALS);
2805                boolean jjtc001 = true;
2806                jjtree.openNodeScope(jjtn001);
2807      try {
2808        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2809        case BOOLEAN_LITERAL:
2810        case IDENTIFIER:
2811        case 84:
2812        case 86:
2813        case 87:
2814          boolean_expression();
2815          break;
2816        case ALL:
2817        case ANY:
2818        case SOME:
2819          all_or_any_expression();
2820          break;
2821        default:
2822          jj_la1[62] = jj_gen;
2823          jj_consume_token(-1);
2824          throw new ParseException();
2825        }
2826      } catch (Throwable JavaDoc jjte001) {
2827                if (jjtc001) {
2828                  jjtree.clearNodeScope(jjtn001);
2829                  jjtc001 = false;
2830                } else {
2831                  jjtree.popNode();
2832                }
2833                if (jjte001 instanceof RuntimeException JavaDoc) {
2834                  {if (true) throw (RuntimeException JavaDoc)jjte001;}
2835                }
2836                if (jjte001 instanceof ParseException) {
2837                  {if (true) throw (ParseException)jjte001;}
2838                }
2839                {if (true) throw (Error JavaDoc)jjte001;}
2840      } finally {
2841                if (jjtc001) {
2842                  jjtree.closeNodeScope(jjtn001, 2);
2843                }
2844      }
2845      break;
2846    case NE:
2847      jj_consume_token(NE);
2848                  EJBQLNotEquals jjtn002 = new EJBQLNotEquals(JJTNOTEQUALS);
2849                  boolean jjtc002 = true;
2850                  jjtree.openNodeScope(jjtn002);
2851      try {
2852        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2853        case BOOLEAN_LITERAL:
2854        case IDENTIFIER:
2855        case 84:
2856        case 86:
2857        case 87:
2858          boolean_expression();
2859          break;
2860        case ALL:
2861        case ANY:
2862        case SOME:
2863          all_or_any_expression();
2864          break;
2865        default:
2866          jj_la1[63] = jj_gen;
2867          jj_consume_token(-1);
2868          throw new ParseException();
2869        }
2870      } catch (Throwable JavaDoc jjte002) {
2871                  if (jjtc002) {
2872                    jjtree.clearNodeScope(jjtn002);
2873                    jjtc002 = false;
2874                  } else {
2875                    jjtree.popNode();
2876                  }
2877                  if (jjte002 instanceof RuntimeException JavaDoc) {
2878                    {if (true) throw (RuntimeException JavaDoc)jjte002;}
2879                  }
2880                  if (jjte002 instanceof ParseException) {
2881                    {if (true) throw (ParseException)jjte002;}
2882                  }
2883                  {if (true) throw (Error JavaDoc)jjte002;}
2884      } finally {
2885                  if (jjtc002) {
2886                    jjtree.closeNodeScope(jjtn002, 2);
2887                  }
2888      }
2889      break;
2890    default:
2891      jj_la1[64] = jj_gen;
2892      jj_consume_token(-1);
2893      throw new ParseException();
2894    }
2895  }
2896
2897  final public void enum_comp() throws ParseException {
2898    enum_expression();
2899    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2900    case EQ:
2901      jj_consume_token(EQ);
2902                EJBQLEquals jjtn001 = new EJBQLEquals(JJTEQUALS);
2903                boolean jjtc001 = true;
2904                jjtree.openNodeScope(jjtn001);
2905      try {
2906        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2907        case IDENTIFIER:
2908        case 84:
2909        case 86:
2910        case 87:
2911          enum_expression();
2912          break;
2913        case ALL:
2914        case ANY:
2915        case SOME:
2916          all_or_any_expression();
2917          break;
2918        default:
2919          jj_la1[65] = jj_gen;
2920          jj_consume_token(-1);
2921          throw new ParseException();
2922        }
2923      } catch (Throwable JavaDoc jjte001) {
2924                if (jjtc001) {
2925                  jjtree.clearNodeScope(jjtn001);
2926                  jjtc001 = false;
2927                } else {
2928                  jjtree.popNode();
2929                }
2930                if (jjte001 instanceof RuntimeException JavaDoc) {
2931                  {if (true) throw (RuntimeException JavaDoc)jjte001;}
2932                }
2933                if (jjte001 instanceof ParseException) {
2934                  {if (true) throw (ParseException)jjte001;}
2935                }
2936                {if (true) throw (Error JavaDoc)jjte001;}
2937      } finally {
2938                if (jjtc001) {
2939                  jjtree.closeNodeScope(jjtn001, 2);
2940                }
2941      }
2942      break;
2943    case NE:
2944      jj_consume_token(NE);
2945                  EJBQLNotEquals jjtn002 = new EJBQLNotEquals(JJTNOTEQUALS);
2946                  boolean jjtc002 = true;
2947                  jjtree.openNodeScope(jjtn002);
2948      try {
2949        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2950        case IDENTIFIER:
2951        case 84:
2952        case 86:
2953        case 87:
2954          enum_expression();
2955          break;
2956        case ALL:
2957        case ANY:
2958        case SOME:
2959          all_or_any_expression();
2960          break;
2961        default:
2962          jj_la1[66] = jj_gen;
2963          jj_consume_token(-1);
2964          throw new ParseException();
2965        }
2966      } catch (Throwable JavaDoc jjte002) {
2967                  if (jjtc002) {
2968                    jjtree.clearNodeScope(jjtn002);
2969                    jjtc002 = false;
2970                  } else {
2971                    jjtree.popNode();
2972                  }
2973                  if (jjte002 instanceof RuntimeException JavaDoc) {
2974                    {if (true) throw (RuntimeException JavaDoc)jjte002;}
2975                  }
2976                  if (jjte002 instanceof ParseException) {
2977                    {if (true) throw (ParseException)jjte002;}
2978                  }
2979                  {if (true) throw (Error JavaDoc)jjte002;}
2980      } finally {
2981                  if (jjtc002) {
2982                    jjtree.closeNodeScope(jjtn002, 2);
2983                  }
2984      }
2985      break;
2986    default:
2987      jj_la1[67] = jj_gen;
2988      jj_consume_token(-1);
2989      throw new ParseException();
2990    }
2991  }
2992
2993  final public void entity_comp() throws ParseException {
2994    entity_bean_expression();
2995    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2996    case EQ:
2997      jj_consume_token(EQ);
2998                 EJBQLEquals jjtn001 = new EJBQLEquals(JJTEQUALS);
2999                 boolean jjtc001 = true;
3000                 jjtree.openNodeScope(jjtn001);
3001      try {
3002        if (jj_2_49(2147483647)) {
3003          all_or_any_expression();
3004        } else {
3005          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3006          case NEW:
3007          case ALL:
3008          case ANY:
3009          case EXISTS:
3010          case SOME:
3011          case EMPTY:
3012          case ASC:
3013          case DESC:
3014          case ORDER:
3015          case BY:
3016          case IS:
3017          case MEMBER:
3018          case OF:
3019          case LIKE:
3020          case ESCAPE:
3021          case BETWEEN:
3022          case NULL:
3023          case AVG:
3024          case MIN:
3025          case MAX:
3026          case SUM:
3027          case COUNT:
3028          case OR:
3029          case AND:
3030          case NOT:
3031          case CONCAT:
3032          case SUBSTRING:
3033          case TRIM:
3034          case LOWER:
3035          case UPPER:
3036          case LEADING:
3037          case TRAILING:
3038          case BOTH:
3039          case LENGTH:
3040          case LOCATE:
3041          case ABS:
3042          case SQRT:
3043          case MOD:
3044          case SIZE:
3045          case CURRENT_DATE:
3046          case CURRENT_TIME:
3047          case CURRENT_TIMESTAMP:
3048          case SELECT:
3049          case DISTINCT:
3050          case FROM:
3051          case UPDATE:
3052          case DELETE:
3053          case WHERE:
3054          case GROUP:
3055          case HAVING:
3056          case AS:
3057          case LEFT:
3058          case OUTER:
3059          case INNER:
3060          case JOIN:
3061          case FETCH:
3062          case IN:
3063          case SET:
3064          case OBJECT:
3065          case IDENTIFIER:
3066          case 86:
3067          case 87:
3068            entity_bean_expression();
3069            break;
3070          default:
3071            jj_la1[68] = jj_gen;
3072            jj_consume_token(-1);
3073            throw new ParseException();
3074          }
3075        }
3076      } catch (Throwable JavaDoc jjte001) {
3077                 if (jjtc001) {
3078                   jjtree.clearNodeScope(jjtn001);
3079                   jjtc001 = false;
3080                 } else {
3081                   jjtree.popNode();
3082                 }
3083                 if (jjte001 instanceof RuntimeException JavaDoc) {
3084                   {if (true) throw (RuntimeException JavaDoc)jjte001;}
3085                 }
3086                 if (jjte001 instanceof ParseException) {
3087                   {if (true) throw (ParseException)jjte001;}
3088                 }
3089                 {if (true) throw (Error JavaDoc)jjte001;}
3090      } finally {
3091                 if (jjtc001) {
3092                   jjtree.closeNodeScope(jjtn001, 2);
3093                 }
3094      }
3095      break;
3096    case NE:
3097      jj_consume_token(NE);
3098                   EJBQLNotEquals jjtn002 = new EJBQLNotEquals(JJTNOTEQUALS);
3099                   boolean jjtc002 = true;
3100                   jjtree.openNodeScope(jjtn002);
3101      try {
3102        if (jj_2_50(2147483647)) {
3103          all_or_any_expression();
3104        } else {
3105          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3106          case NEW:
3107          case ALL:
3108          case ANY:
3109          case EXISTS:
3110          case SOME:
3111          case EMPTY:
3112          case ASC:
3113          case DESC:
3114          case ORDER:
3115          case BY:
3116          case IS:
3117          case MEMBER:
3118          case OF:
3119          case LIKE:
3120          case ESCAPE:
3121          case BETWEEN:
3122          case NULL:
3123          case AVG:
3124          case MIN:
3125          case MAX:
3126          case SUM:
3127          case COUNT:
3128          case OR:
3129          case AND:
3130          case NOT:
3131          case CONCAT:
3132          case SUBSTRING:
3133          case TRIM:
3134          case LOWER:
3135          case UPPER:
3136          case LEADING:
3137          case TRAILING:
3138          case BOTH:
3139          case LENGTH:
3140          case LOCATE:
3141          case ABS:
3142          case SQRT:
3143          case MOD:
3144          case SIZE:
3145          case CURRENT_DATE:
3146          case CURRENT_TIME:
3147          case CURRENT_TIMESTAMP:
3148          case SELECT:
3149          case DISTINCT:
3150          case FROM:
3151          case UPDATE:
3152          case DELETE:
3153          case WHERE:
3154          case GROUP:
3155          case HAVING:
3156          case AS:
3157          case LEFT:
3158          case OUTER:
3159          case INNER:
3160          case JOIN:
3161          case FETCH:
3162          case IN:
3163          case SET:
3164          case OBJECT:
3165          case IDENTIFIER:
3166          case 86:
3167          case 87:
3168            entity_bean_expression();
3169            break;
3170          default:
3171            jj_la1[69] = jj_gen;
3172            jj_consume_token(-1);
3173            throw new ParseException();
3174          }
3175        }
3176      } catch (Throwable JavaDoc jjte002) {
3177                   if (jjtc002) {
3178                     jjtree.clearNodeScope(jjtn002);
3179                     jjtc002 = false;
3180                   } else {
3181                     jjtree.popNode();
3182                   }
3183                   if (jjte002 instanceof RuntimeException JavaDoc) {
3184                     {if (true) throw (RuntimeException JavaDoc)jjte002;}
3185                   }
3186                   if (jjte002 instanceof ParseException) {
3187                     {if (true) throw (ParseException)jjte002;}
3188                   }
3189                   {if (true) throw (Error JavaDoc)jjte002;}
3190      } finally {
3191                   if (jjtc002) {
3192                     jjtree.closeNodeScope(jjtn002, 2);
3193                   }
3194      }
3195      break;
3196    default:
3197      jj_la1[70] = jj_gen;
3198      jj_consume_token(-1);
3199      throw new ParseException();
3200    }
3201  }
3202
3203  final public void arithmetic_comp() throws ParseException {
3204    arithmetic_expression();
3205    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3206    case EQ:
3207      jj_consume_token(EQ);
3208                EJBQLEquals jjtn001 = new EJBQLEquals(JJTEQUALS);
3209                boolean jjtc001 = true;
3210                jjtree.openNodeScope(jjtn001);
3211      try {
3212        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3213        case PLUS:
3214        case MINUS:
3215        case AVG:
3216        case MIN:
3217        case MAX:
3218        case SUM:
3219        case COUNT:
3220        case LENGTH:
3221        case LOCATE:
3222        case ABS:
3223        case SQRT:
3224        case MOD:
3225        case SIZE:
3226        case SELECT:
3227        case INTEGER_LITERAL:
3228        case DECIMAL_LITERAL:
3229        case IDENTIFIER:
3230        case 84:
3231        case 86:
3232        case 87:
3233          arithmetic_expression();
3234          break;
3235        case ALL:
3236        case ANY:
3237        case SOME:
3238          all_or_any_expression();
3239          break;
3240        default:
3241          jj_la1[71] = jj_gen;
3242          jj_consume_token(-1);
3243          throw new ParseException();
3244        }
3245      } catch (Throwable JavaDoc jjte001) {
3246                if (jjtc001) {
3247                  jjtree.clearNodeScope(jjtn001);
3248                  jjtc001 = false;
3249                } else {
3250                  jjtree.popNode();
3251                }
3252                if (jjte001 instanceof RuntimeException JavaDoc) {
3253                  {if (true) throw (RuntimeException JavaDoc)jjte001;}
3254                }
3255                if (jjte001 instanceof ParseException) {
3256                  {if (true) throw (ParseException)jjte001;}
3257                }
3258                {if (true) throw (Error JavaDoc)jjte001;}
3259      } finally {
3260                if (jjtc001) {
3261                  jjtree.closeNodeScope(jjtn001, 2);
3262                }
3263      }
3264      break;
3265    case GT:
3266      jj_consume_token(GT);
3267                  EJBQLGreaterThan jjtn002 = new EJBQLGreaterThan(JJTGREATERTHAN);
3268                  boolean jjtc002 = true;
3269                  jjtree.openNodeScope(jjtn002);
3270      try {
3271        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3272        case PLUS:
3273        case MINUS:
3274        case AVG:
3275        case MIN:
3276        case MAX:
3277        case SUM:
3278        case COUNT:
3279        case LENGTH:
3280        case LOCATE:
3281        case ABS:
3282        case SQRT:
3283        case MOD:
3284        case SIZE:
3285        case SELECT:
3286        case INTEGER_LITERAL:
3287        case DECIMAL_LITERAL:
3288        case IDENTIFIER:
3289        case 84:
3290        case 86:
3291        case 87:
3292          arithmetic_expression();
3293          break;
3294        case ALL:
3295        case ANY:
3296        case SOME:
3297          all_or_any_expression();
3298          break;
3299        default:
3300          jj_la1[72] = jj_gen;
3301          jj_consume_token(-1);
3302          throw new ParseException();
3303        }
3304      } catch (Throwable JavaDoc jjte002) {
3305                  if (jjtc002) {
3306                    jjtree.clearNodeScope(jjtn002);
3307                    jjtc002 = false;
3308                  } else {
3309                    jjtree.popNode();
3310                  }
3311                  if (jjte002 instanceof RuntimeException JavaDoc) {
3312                    {if (true) throw (RuntimeException JavaDoc)jjte002;}
3313                  }
3314                  if (jjte002 instanceof ParseException) {
3315                    {if (true) throw (ParseException)jjte002;}
3316                  }
3317                  {if (true) throw (Error JavaDoc)jjte002;}
3318      } finally {
3319                  if (jjtc002) {
3320                    jjtree.closeNodeScope(jjtn002, 2);
3321                  }
3322      }
3323      break;
3324    case GE:
3325      jj_consume_token(GE);
3326                  EJBQLGreaterOrEqual jjtn003 = new EJBQLGreaterOrEqual(JJTGREATEROREQUAL);
3327                  boolean jjtc003 = true;
3328                  jjtree.openNodeScope(jjtn003);
3329      try {
3330        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3331        case PLUS:
3332        case MINUS:
3333        case AVG:
3334        case MIN:
3335        case MAX:
3336        case SUM:
3337        case COUNT:
3338        case LENGTH:
3339        case LOCATE:
3340        case ABS:
3341        case SQRT:
3342        case MOD:
3343        case SIZE:
3344        case SELECT:
3345        case INTEGER_LITERAL:
3346        case DECIMAL_LITERAL:
3347        case IDENTIFIER:
3348        case 84:
3349        case 86:
3350        case 87:
3351          arithmetic_expression();
3352          break;
3353        case ALL:
3354        case ANY:
3355        case SOME:
3356          all_or_any_expression();
3357          break;
3358        default:
3359          jj_la1[73] = jj_gen;
3360          jj_consume_token(-1);
3361          throw new ParseException();
3362        }
3363      } catch (Throwable JavaDoc jjte003) {
3364                  if (jjtc003) {
3365                    jjtree.clearNodeScope(jjtn003);
3366                    jjtc003 = false;
3367                  } else {
3368                    jjtree.popNode();
3369                  }
3370                  if (jjte003 instanceof RuntimeException JavaDoc) {
3371                    {if (true) throw (RuntimeException JavaDoc)jjte003;}
3372                  }
3373                  if (jjte003 instanceof ParseException) {
3374                    {if (true) throw (ParseException)jjte003;}
3375                  }
3376                  {if (true) throw (Error JavaDoc)jjte003;}
3377      } finally {
3378                  if (jjtc003) {
3379                    jjtree.closeNodeScope(jjtn003, 2);
3380                  }
3381      }
3382      break;
3383    case LT:
3384      jj_consume_token(LT);
3385                  EJBQLLessThan jjtn004 = new EJBQLLessThan(JJTLESSTHAN);
3386                  boolean jjtc004 = true;
3387                  jjtree.openNodeScope(jjtn004);
3388      try {
3389        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3390        case PLUS:
3391        case MINUS:
3392        case AVG:
3393        case MIN:
3394        case MAX:
3395        case SUM:
3396        case COUNT:
3397        case LENGTH:
3398        case LOCATE:
3399        case ABS:
3400        case SQRT:
3401        case MOD:
3402        case SIZE:
3403        case SELECT:
3404        case INTEGER_LITERAL:
3405        case DECIMAL_LITERAL:
3406        case IDENTIFIER:
3407        case 84:
3408        case 86:
3409        case 87:
3410          arithmetic_expression();
3411          break;
3412        case ALL:
3413        case ANY:
3414        case SOME:
3415          all_or_any_expression();
3416          break;
3417        default:
3418          jj_la1[74] = jj_gen;
3419          jj_consume_token(-1);
3420          throw new ParseException();
3421        }
3422      } catch (Throwable JavaDoc jjte004) {
3423                  if (jjtc004) {
3424                    jjtree.clearNodeScope(jjtn004);
3425                    jjtc004 = false;
3426                  } else {
3427                    jjtree.popNode();
3428                  }
3429                  if (jjte004 instanceof RuntimeException JavaDoc) {
3430                    {if (true) throw (RuntimeException JavaDoc)jjte004;}
3431                  }
3432                  if (jjte004 instanceof ParseException) {
3433                    {if (true) throw (ParseException)jjte004;}
3434                  }
3435                  {if (true) throw (Error JavaDoc)jjte004;}
3436      } finally {
3437                  if (jjtc004) {
3438                    jjtree.closeNodeScope(jjtn004, 2);
3439                  }
3440      }
3441      break;
3442    case LE:
3443      jj_consume_token(LE);
3444                  EJBQLLessOrEqual jjtn005 = new EJBQLLessOrEqual(JJTLESSOREQUAL);
3445                  boolean jjtc005 = true;
3446                  jjtree.openNodeScope(jjtn005);
3447      try {
3448        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3449        case PLUS:
3450        case MINUS:
3451        case AVG:
3452        case MIN:
3453        case MAX:
3454        case SUM:
3455        case COUNT:
3456        case LENGTH:
3457        case LOCATE:
3458        case ABS:
3459        case SQRT:
3460        case MOD:
3461        case SIZE:
3462        case SELECT:
3463        case INTEGER_LITERAL:
3464        case DECIMAL_LITERAL:
3465        case IDENTIFIER:
3466        case 84:
3467        case 86:
3468        case 87:
3469          arithmetic_expression();
3470          break;
3471        case ALL:
3472        case ANY:
3473        case SOME:
3474          all_or_any_expression();
3475          break;
3476        default:
3477          jj_la1[75] = jj_gen;
3478          jj_consume_token(-1);
3479          throw new ParseException();
3480        }
3481      } catch (Throwable JavaDoc jjte005) {
3482                  if (jjtc005) {
3483                    jjtree.clearNodeScope(jjtn005);
3484                    jjtc005 = false;
3485                  } else {
3486                    jjtree.popNode();
3487                  }
3488                  if (jjte005 instanceof RuntimeException JavaDoc) {
3489                    {if (true) throw (RuntimeException JavaDoc)jjte005;}
3490                  }
3491                  if (jjte005 instanceof ParseException) {
3492                    {if (true) throw (ParseException)jjte005;}
3493                  }
3494                  {if (true) throw (Error JavaDoc)jjte005;}
3495      } finally {
3496                  if (jjtc005) {
3497                    jjtree.closeNodeScope(jjtn005, 2);
3498                  }
3499      }
3500      break;
3501    case NE:
3502      jj_consume_token(NE);
3503                  EJBQLNotEquals jjtn006 = new EJBQLNotEquals(JJTNOTEQUALS);
3504                  boolean jjtc006 = true;
3505                  jjtree.openNodeScope(jjtn006);
3506      try {
3507        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3508        case PLUS:
3509        case MINUS:
3510        case AVG:
3511        case MIN:
3512        case MAX:
3513        case SUM:
3514        case COUNT:
3515        case LENGTH:
3516        case LOCATE:
3517        case ABS:
3518        case SQRT:
3519        case MOD:
3520        case SIZE:
3521        case SELECT:
3522        case INTEGER_LITERAL:
3523        case DECIMAL_LITERAL:
3524        case IDENTIFIER:
3525        case 84:
3526        case 86:
3527        case 87:
3528          arithmetic_expression();
3529          break;
3530        case ALL:
3531        case ANY:
3532        case SOME:
3533          all_or_any_expression();
3534          break;
3535        default:
3536          jj_la1[76] = jj_gen;
3537          jj_consume_token(-1);
3538          throw new ParseException();
3539        }
3540      } catch (Throwable JavaDoc jjte006) {
3541                  if (jjtc006) {
3542                    jjtree.clearNodeScope(jjtn006);
3543                    jjtc006 = false;
3544                  } else {
3545                    jjtree.popNode();
3546                  }
3547                  if (jjte006 instanceof RuntimeException JavaDoc) {
3548                    {if (true) throw (RuntimeException JavaDoc)jjte006;}
3549                  }
3550                  if (jjte006 instanceof ParseException) {
3551                    {if (true) throw (ParseException)jjte006;}
3552                  }
3553                  {if (true) throw (Error JavaDoc)jjte006;}
3554      } finally {
3555                  if (jjtc006) {
3556                    jjtree.closeNodeScope(jjtn006, 2);
3557                  }
3558      }
3559      break;
3560    default:
3561      jj_la1[77] = jj_gen;
3562      jj_consume_token(-1);
3563      throw new ParseException();
3564    }
3565  }
3566
3567  final public void datetime_comp() throws ParseException {
3568    datetime_expression();
3569    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3570    case EQ:
3571      jj_consume_token(EQ);
3572                EJBQLEquals jjtn001 = new EJBQLEquals(JJTEQUALS);
3573                boolean jjtc001 = true;
3574                jjtree.openNodeScope(jjtn001);
3575      try {
3576        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3577        case CURRENT_DATE:
3578        case CURRENT_TIME:
3579        case CURRENT_TIMESTAMP:
3580        case IDENTIFIER:
3581        case 84:
3582        case 86:
3583        case 87:
3584          datetime_expression();
3585          break;
3586        case ALL:
3587        case ANY:
3588        case SOME:
3589          all_or_any_expression();
3590          break;
3591        default:
3592          jj_la1[78] = jj_gen;
3593          jj_consume_token(-1);
3594          throw new ParseException();
3595        }
3596      } catch (Throwable JavaDoc jjte001) {
3597                if (jjtc001) {
3598                  jjtree.clearNodeScope(jjtn001);
3599                  jjtc001 = false;
3600                } else {
3601                  jjtree.popNode();
3602                }
3603                if (jjte001 instanceof RuntimeException JavaDoc) {
3604                  {if (true) throw (RuntimeException JavaDoc)jjte001;}
3605                }
3606                if (jjte001 instanceof ParseException) {
3607                  {if (true) throw (ParseException)jjte001;}
3608                }
3609                {if (true) throw (Error JavaDoc)jjte001;}
3610      } finally {
3611                if (jjtc001) {
3612                  jjtree.closeNodeScope(jjtn001, 2);
3613                }
3614      }
3615      break;
3616    case GT:
3617      jj_consume_token(GT);
3618                  EJBQLGreaterThan jjtn002 = new EJBQLGreaterThan(JJTGREATERTHAN);
3619                  boolean jjtc002 = true;
3620                  jjtree.openNodeScope(jjtn002);
3621      try {
3622        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3623        case CURRENT_DATE:
3624        case CURRENT_TIME:
3625        case CURRENT_TIMESTAMP:
3626        case IDENTIFIER:
3627        case 84:
3628        case 86:
3629        case 87:
3630          datetime_expression();
3631          break;
3632        case ALL:
3633        case ANY:
3634        case SOME:
3635          all_or_any_expression();
3636          break;
3637        default:
3638          jj_la1[79] = jj_gen;
3639          jj_consume_token(-1);
3640          throw new ParseException();
3641        }
3642      } catch (Throwable JavaDoc jjte002) {
3643                  if (jjtc002) {
3644                    jjtree.clearNodeScope(jjtn002);
3645                    jjtc002 = false;
3646                  } else {
3647                    jjtree.popNode();
3648                  }
3649                  if (jjte002 instanceof RuntimeException JavaDoc) {
3650                    {if (true) throw (RuntimeException JavaDoc)jjte002;}
3651                  }
3652                  if (jjte002 instanceof ParseException) {
3653                    {if (true) throw (ParseException)jjte002;}
3654                  }
3655                  {if (true) throw (Error JavaDoc)jjte002;}
3656      } finally {
3657                  if (jjtc002) {
3658                    jjtree.closeNodeScope(jjtn002, 2);
3659                  }
3660      }
3661      break;
3662    case GE:
3663      jj_consume_token(GE);
3664                  EJBQLGreaterOrEqual jjtn003 = new EJBQLGreaterOrEqual(JJTGREATEROREQUAL);
3665                  boolean jjtc003 = true;
3666                  jjtree.openNodeScope(jjtn003);
3667      try {
3668        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3669        case CURRENT_DATE:
3670        case CURRENT_TIME:
3671        case CURRENT_TIMESTAMP:
3672        case IDENTIFIER:
3673        case 84:
3674        case 86:
3675        case 87:
3676          datetime_expression();
3677          break;
3678        case ALL:
3679        case ANY:
3680        case SOME:
3681          all_or_any_expression();
3682          break;
3683        default:
3684          jj_la1[80] = jj_gen;
3685          jj_consume_token(-1);
3686          throw new ParseException();
3687        }
3688      } catch (Throwable JavaDoc jjte003) {
3689                  if (jjtc003) {
3690                    jjtree.clearNodeScope(jjtn003);
3691                    jjtc003 = false;
3692                  } else {
3693                    jjtree.popNode();
3694                  }
3695                  if (jjte003 instanceof RuntimeException JavaDoc) {
3696                    {if (true) throw (RuntimeException JavaDoc)jjte003;}
3697                  }
3698                  if (jjte003 instanceof ParseException) {
3699                    {if (true) throw (ParseException)jjte003;}
3700                  }
3701                  {if (true) throw (Error JavaDoc)jjte003;}
3702      } finally {
3703                  if (jjtc003) {
3704                    jjtree.closeNodeScope(jjtn003, 2);
3705                  }
3706      }
3707      break;
3708    case LT:
3709      jj_consume_token(LT);
3710                  EJBQLLessThan jjtn004 = new EJBQLLessThan(JJTLESSTHAN);
3711                  boolean jjtc004 = true;
3712                  jjtree.openNodeScope(jjtn004);
3713      try {
3714        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3715        case CURRENT_DATE:
3716        case CURRENT_TIME:
3717        case CURRENT_TIMESTAMP:
3718        case IDENTIFIER:
3719        case 84:
3720        case 86:
3721        case 87:
3722          datetime_expression();
3723          break;
3724        case ALL:
3725        case ANY:
3726        case SOME:
3727          all_or_any_expression();
3728          break;
3729        default:
3730          jj_la1[81] = jj_gen;
3731          jj_consume_token(-1);
3732          throw new ParseException();
3733        }
3734      } catch (Throwable JavaDoc jjte004) {
3735                  if (jjtc004) {
3736                    jjtree.clearNodeScope(jjtn004);
3737                    jjtc004 = false;
3738                  } else {
3739                    jjtree.popNode();
3740                  }
3741                  if (jjte004 instanceof RuntimeException JavaDoc) {
3742                    {if (true) throw (RuntimeException JavaDoc)jjte004;}
3743                  }
3744                  if (jjte004 instanceof ParseException) {
3745                    {if (true) throw (ParseException)jjte004;}
3746                  }
3747                  {if (true) throw (Error JavaDoc)jjte004;}
3748      } finally {
3749                  if (jjtc004) {
3750                    jjtree.closeNodeScope(jjtn004, 2);
3751                  }
3752      }
3753      break;
3754    case LE:
3755      jj_consume_token(LE);
3756                  EJBQLLessOrEqual jjtn005 = new EJBQLLessOrEqual(JJTLESSOREQUAL);
3757                  boolean jjtc005 = true;
3758                  jjtree.openNodeScope(jjtn005);
3759      try {
3760        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3761        case CURRENT_DATE:
3762        case CURRENT_TIME:
3763        case CURRENT_TIMESTAMP:
3764        case IDENTIFIER:
3765        case 84:
3766        case 86:
3767        case 87:
3768          datetime_expression();
3769          break;
3770        case ALL:
3771        case ANY:
3772        case SOME:
3773          all_or_any_expression();
3774          break;
3775        default:
3776          jj_la1[82] = jj_gen;
3777          jj_consume_token(-1);
3778          throw new ParseException();
3779        }
3780      } catch (Throwable JavaDoc jjte005) {
3781                  if (jjtc005) {
3782                    jjtree.clearNodeScope(jjtn005);
3783                    jjtc005 = false;
3784                  } else {
3785                    jjtree.popNode();
3786                  }
3787                  if (jjte005 instanceof RuntimeException JavaDoc) {
3788                    {if (true) throw (RuntimeException JavaDoc)jjte005;}
3789                  }
3790                  if (jjte005 instanceof ParseException) {
3791                    {if (true) throw (ParseException)jjte005;}
3792                  }
3793                  {if (true) throw (Error JavaDoc)jjte005;}
3794      } finally {
3795                  if (jjtc005) {
3796                    jjtree.closeNodeScope(jjtn005, 2);
3797                  }
3798      }
3799      break;
3800    case NE:
3801      jj_consume_token(NE);
3802                  EJBQLNotEquals jjtn006 = new EJBQLNotEquals(JJTNOTEQUALS);
3803                  boolean jjtc006 = true;
3804                  jjtree.openNodeScope(jjtn006);
3805      try {
3806        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3807        case CURRENT_DATE:
3808        case CURRENT_TIME:
3809        case CURRENT_TIMESTAMP:
3810        case IDENTIFIER:
3811        case 84:
3812        case 86:
3813        case 87:
3814          datetime_expression();
3815          break;
3816        case ALL:
3817        case ANY:
3818        case SOME:
3819          all_or_any_expression();
3820          break;
3821        default:
3822          jj_la1[83] = jj_gen;
3823          jj_consume_token(-1);
3824          throw new ParseException();
3825        }
3826      } catch (Throwable JavaDoc jjte006) {
3827                  if (jjtc006) {
3828                    jjtree.clearNodeScope(jjtn006);
3829                    jjtc006 = false;
3830                  } else {
3831                    jjtree.popNode();
3832                  }
3833                  if (jjte006 instanceof RuntimeException JavaDoc) {
3834                    {if (true) throw (RuntimeException JavaDoc)jjte006;}
3835                  }
3836                  if (jjte006 instanceof ParseException) {
3837                    {if (true) throw (ParseException)jjte006;}
3838                  }
3839                  {if (true) throw (Error JavaDoc)jjte006;}
3840      } finally {
3841                  if (jjtc006) {
3842                    jjtree.closeNodeScope(jjtn006, 2);
3843                  }
3844      }
3845      break;
3846    default:
3847      jj_la1[84] = jj_gen;
3848      jj_consume_token(-1);
3849      throw new ParseException();
3850    }
3851  }
3852
3853  final public void arithmetic_value() throws ParseException {
3854    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3855    case IDENTIFIER:
3856      path();
3857      break;
3858    case LENGTH:
3859    case LOCATE:
3860    case ABS:
3861    case SQRT:
3862    case MOD:
3863    case SIZE:
3864      functions_returning_numerics();
3865      break;
3866    case 84:
3867      jj_consume_token(84);
3868      subquery();
3869      jj_consume_token(85);
3870      break;
3871    default:
3872      jj_la1[85] = jj_gen;
3873      jj_consume_token(-1);
3874      throw new ParseException();
3875    }
3876  }
3877
3878/* changed to eliminate left recursion */
3879  final public void arithmetic_expression() throws ParseException {
3880    arithmetic_term();
3881    label_14:
3882    while (true) {
3883      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3884      case PLUS:
3885      case MINUS:
3886        ;
3887        break;
3888      default:
3889        jj_la1[86] = jj_gen;
3890        break label_14;
3891      }
3892      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3893      case PLUS:
3894        jj_consume_token(PLUS);
3895                           EJBQLAdd jjtn001 = new EJBQLAdd(JJTADD);
3896                           boolean jjtc001 = true;
3897                           jjtree.openNodeScope(jjtn001);
3898        try {
3899          arithmetic_expression();
3900        } catch (Throwable JavaDoc jjte001) {
3901                           if (jjtc001) {
3902                             jjtree.clearNodeScope(jjtn001);
3903                             jjtc001 = false;
3904                           } else {
3905                             jjtree.popNode();
3906                           }
3907                           if (jjte001 instanceof RuntimeException JavaDoc) {
3908                             {if (true) throw (RuntimeException JavaDoc)jjte001;}
3909                           }
3910                           if (jjte001 instanceof ParseException) {
3911                             {if (true) throw (ParseException)jjte001;}
3912                           }
3913                           {if (true) throw (Error JavaDoc)jjte001;}
3914        } finally {
3915                           if (jjtc001) {
3916                             jjtree.closeNodeScope(jjtn001, 2);
3917                           }
3918        }
3919        break;
3920      case MINUS:
3921        jj_consume_token(MINUS);
3922                             EJBQLSubtract jjtn002 = new EJBQLSubtract(JJTSUBTRACT);
3923                             boolean jjtc002 = true;
3924                             jjtree.openNodeScope(jjtn002);
3925        try {
3926          arithmetic_expression();
3927        } catch (Throwable JavaDoc jjte002) {
3928                             if (jjtc002) {
3929                               jjtree.clearNodeScope(jjtn002);
3930                               jjtc002 = false;
3931                             } else {
3932                               jjtree.popNode();
3933                             }
3934                             if (jjte002 instanceof RuntimeException JavaDoc) {
3935                               {if (true) throw (RuntimeException JavaDoc)jjte002;}
3936                             }
3937                             if (jjte002 instanceof ParseException) {
3938                               {if (true) throw (ParseException)jjte002;}
3939                             }
3940                             {if (true) throw (Error JavaDoc)jjte002;}
3941        } finally {
3942                             if (jjtc002) {
3943                               jjtree.closeNodeScope(jjtn002, 2);
3944                             }
3945        }
3946        break;
3947      default:
3948        jj_la1[87] = jj_gen;
3949        jj_consume_token(-1);
3950        throw new ParseException();
3951      }
3952    }
3953  }
3954
3955/* changed to eliminate left recursion */
3956  final public void arithmetic_term() throws ParseException {
3957    arithmetic_factor();
3958    label_15:
3959    while (true) {
3960      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3961      case TIMES:
3962      case DIV:
3963        ;
3964        break;
3965      default:
3966        jj_la1[88] = jj_gen;
3967        break label_15;
3968      }
3969      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3970      case TIMES:
3971        jj_consume_token(TIMES);
3972                            EJBQLMultiply jjtn001 = new EJBQLMultiply(JJTMULTIPLY);
3973                            boolean jjtc001 = true;
3974                            jjtree.openNodeScope(jjtn001);
3975        try {
3976          arithmetic_term();
3977        } catch (Throwable JavaDoc jjte001) {
3978                            if (jjtc001) {
3979                              jjtree.clearNodeScope(jjtn001);
3980                              jjtc001 = false;
3981                            } else {
3982                              jjtree.popNode();
3983                            }
3984                            if (jjte001 instanceof RuntimeException JavaDoc) {
3985                              {if (true) throw (RuntimeException JavaDoc)jjte001;}
3986                            }
3987                            if (jjte001 instanceof ParseException) {
3988                              {if (true) throw (ParseException)jjte001;}
3989                            }
3990                            {if (true) throw (Error JavaDoc)jjte001;}
3991        } finally {
3992                            if (jjtc001) {
3993                              jjtree.closeNodeScope(jjtn001, 2);
3994                            }
3995        }
3996        break;
3997      case DIV:
3998        jj_consume_token(DIV);
3999                           EJBQLDivide jjtn002 = new EJBQLDivide(JJTDIVIDE);
4000                           boolean jjtc002 = true;
4001                           jjtree.openNodeScope(jjtn002);
4002        try {
4003          arithmetic_term();
4004        } catch (Throwable JavaDoc jjte002) {
4005                           if (jjtc002) {
4006                             jjtree.clearNodeScope(jjtn002);
4007                             jjtc002 = false;
4008                           } else {
4009                             jjtree.popNode();
4010                           }
4011                           if (jjte002 instanceof RuntimeException JavaDoc) {
4012                             {if (true) throw (RuntimeException JavaDoc)jjte002;}
4013                           }
4014                           if (jjte002 instanceof ParseException) {
4015                             {if (true) throw (ParseException)jjte002;}
4016                           }
4017                           {if (true) throw (Error JavaDoc)jjte002;}
4018        } finally {
4019                           if (jjtc002) {
4020                             jjtree.closeNodeScope(jjtn002, 2);
4021                           }
4022        }
4023        break;
4024      default:
4025        jj_la1[89] = jj_gen;
4026        jj_consume_token(-1);
4027        throw new ParseException();
4028      }
4029    }
4030  }
4031
4032  final public void arithmetic_factor() throws ParseException {
4033    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4034    case PLUS:
4035    case MINUS:
4036    case INTEGER_LITERAL:
4037    case DECIMAL_LITERAL:
4038      numeric_literal();
4039      break;
4040    case 86:
4041    case 87:
4042      input_parameter();
4043      break;
4044    case IDENTIFIER:
4045      path();
4046      break;
4047    default:
4048      jj_la1[90] = jj_gen;
4049      if (jj_2_51(2)) {
4050        jj_consume_token(84);
4051        arithmetic_expression();
4052        jj_consume_token(85);
4053      } else {
4054        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4055        case LENGTH:
4056        case LOCATE:
4057        case ABS:
4058        case SQRT:
4059        case MOD:
4060        case SIZE:
4061          functions_returning_numerics();
4062          break;
4063        case AVG:
4064        case MIN:
4065        case MAX:
4066        case SUM:
4067        case COUNT:
4068          aggregate_select_expression();
4069          break;
4070        case SELECT:
4071          subquery();
4072          break;
4073        default:
4074          jj_la1[91] = jj_gen;
4075          jj_consume_token(-1);
4076          throw new ParseException();
4077        }
4078      }
4079    }
4080  }
4081
4082  final public void negative() throws ParseException {
4083                             /*@bgen(jjtree) Negative */
4084  EJBQLNegative jjtn000 = new EJBQLNegative(JJTNEGATIVE);
4085  boolean jjtc000 = true;
4086  jjtree.openNodeScope(jjtn000);
4087    try {
4088      jj_consume_token(MINUS);
4089    } finally {
4090          if (jjtc000) {
4091            jjtree.closeNodeScope(jjtn000, true);
4092          }
4093    }
4094  }
4095
4096  final public void string_value() throws ParseException {
4097    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4098    case IDENTIFIER:
4099      path();
4100      break;
4101    case CONCAT:
4102    case SUBSTRING:
4103    case TRIM:
4104    case LOWER:
4105    case UPPER:
4106      functions_returning_strings();
4107      break;
4108    case 84:
4109      jj_consume_token(84);
4110      subquery();
4111      jj_consume_token(85);
4112      break;
4113    default:
4114      jj_la1[92] = jj_gen;
4115      jj_consume_token(-1);
4116      throw new ParseException();
4117    }
4118  }
4119
4120  final public void string_expression() throws ParseException {
4121    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4122    case 86:
4123    case 87:
4124      input_parameter();
4125      break;
4126    case CONCAT:
4127    case SUBSTRING:
4128    case TRIM:
4129    case LOWER:
4130    case UPPER:
4131    case STRING_LITERAL:
4132    case IDENTIFIER:
4133    case 84:
4134      string_primary();
4135      break;
4136    default:
4137      jj_la1[93] = jj_gen;
4138      jj_consume_token(-1);
4139      throw new ParseException();
4140    }
4141  }
4142
4143  final public void string_primary() throws ParseException {
4144    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4145    case STRING_LITERAL:
4146      string_literal();
4147      break;
4148    case IDENTIFIER:
4149      path();
4150      break;
4151    default:
4152      jj_la1[94] = jj_gen;
4153      if (jj_2_52(2)) {
4154        jj_consume_token(84);
4155        string_expression();
4156        jj_consume_token(85);
4157      } else {
4158        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4159        case CONCAT:
4160        case SUBSTRING:
4161        case TRIM:
4162        case LOWER:
4163        case UPPER:
4164          functions_returning_strings();
4165          break;
4166        default:
4167          jj_la1[95] = jj_gen;
4168          if (jj_2_53(2)) {
4169            jj_consume_token(84);
4170            subquery();
4171            jj_consume_token(85);
4172          } else {
4173            jj_consume_token(-1);
4174            throw new ParseException();
4175          }
4176        }
4177      }
4178    }
4179  }
4180
4181  final public void datetime_expression() throws ParseException {
4182    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4183    case CURRENT_DATE:
4184    case CURRENT_TIME:
4185    case CURRENT_TIMESTAMP:
4186    case IDENTIFIER:
4187    case 86:
4188    case 87:
4189      datetime_primary();
4190      break;
4191    case 84:
4192      jj_consume_token(84);
4193      subquery();
4194      jj_consume_token(85);
4195      break;
4196    default:
4197      jj_la1[96] = jj_gen;
4198      jj_consume_token(-1);
4199      throw new ParseException();
4200    }
4201  }
4202
4203  final public void datetime_primary() throws ParseException {
4204    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4205    case IDENTIFIER:
4206      path();
4207      break;
4208    case CURRENT_DATE:
4209    case CURRENT_TIME:
4210    case CURRENT_TIMESTAMP:
4211      functions_returning_datetime();
4212      break;
4213    case 86:
4214    case 87:
4215      input_parameter();
4216      break;
4217    default:
4218      jj_la1[97] = jj_gen;
4219      jj_consume_token(-1);
4220      throw new ParseException();
4221    }
4222  }
4223
4224  final public void boolean_value() throws ParseException {
4225    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4226    case IDENTIFIER:
4227      path();
4228      break;
4229    case 84:
4230      jj_consume_token(84);
4231      subquery();
4232      jj_consume_token(85);
4233      break;
4234    default:
4235      jj_la1[98] = jj_gen;
4236      jj_consume_token(-1);
4237      throw new ParseException();
4238    }
4239  }
4240
4241  final public void boolean_expression() throws ParseException {
4242    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4243    case BOOLEAN_LITERAL:
4244    case IDENTIFIER:
4245    case 86:
4246    case 87:
4247      boolean_primary();
4248      break;
4249    case 84:
4250      jj_consume_token(84);
4251      subquery();
4252      jj_consume_token(85);
4253      break;
4254    default:
4255      jj_la1[99] = jj_gen;
4256      jj_consume_token(-1);
4257      throw new ParseException();
4258    }
4259  }
4260
4261  final public void boolean_primary() throws ParseException {
4262    if (jj_2_54(2)) {
4263      path();
4264    } else {
4265      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4266      case BOOLEAN_LITERAL:
4267        boolean_literal();
4268        break;
4269      case 86:
4270      case 87:
4271        input_parameter();
4272        break;
4273      default:
4274        jj_la1[100] = jj_gen;
4275        jj_consume_token(-1);
4276        throw new ParseException();
4277      }
4278    }
4279  }
4280
4281  final public void enum_expression() throws ParseException {
4282    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4283    case IDENTIFIER:
4284    case 86:
4285    case 87:
4286      enum_primary();
4287      break;
4288    case 84:
4289      jj_consume_token(84);
4290      subquery();
4291      jj_consume_token(85);
4292      break;
4293    default:
4294      jj_la1[101] = jj_gen;
4295      jj_consume_token(-1);
4296      throw new ParseException();
4297    }
4298  }
4299
4300  final public void enum_primary() throws ParseException {
4301    if (jj_2_55(2)) {
4302      path();
4303    } else if (jj_2_56(2147483647)) {
4304      enum_literal();
4305    } else if (jj_2_57(2147483647)) {
4306      input_parameter();
4307    } else {
4308      jj_consume_token(-1);
4309      throw new ParseException();
4310    }
4311  }
4312
4313  final public void enum_literal() throws ParseException {
4314    path();
4315  }
4316
4317  final public void entity_bean_value() throws ParseException {
4318    if (jj_2_58(2147483647)) {
4319      path();
4320    } else {
4321      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4322      case NEW:
4323      case ALL:
4324      case ANY:
4325      case EXISTS:
4326      case SOME:
4327      case EMPTY:
4328      case ASC:
4329      case DESC:
4330      case ORDER:
4331      case BY:
4332      case IS:
4333      case MEMBER:
4334      case OF:
4335      case LIKE:
4336      case ESCAPE:
4337      case BETWEEN:
4338      case NULL:
4339      case AVG:
4340      case MIN:
4341      case MAX:
4342      case SUM:
4343      case COUNT:
4344      case OR:
4345      case AND:
4346      case NOT:
4347      case CONCAT:
4348      case SUBSTRING:
4349      case TRIM:
4350      case LOWER:
4351      case UPPER:
4352      case LEADING:
4353      case TRAILING:
4354      case BOTH:
4355      case LENGTH:
4356      case LOCATE:
4357      case ABS:
4358      case SQRT:
4359      case MOD:
4360      case SIZE:
4361      case CURRENT_DATE:
4362      case CURRENT_TIME:
4363      case CURRENT_TIMESTAMP:
4364      case SELECT:
4365      case DISTINCT:
4366      case FROM:
4367      case UPDATE:
4368      case DELETE:
4369      case WHERE:
4370      case GROUP:
4371      case HAVING:
4372      case AS:
4373      case LEFT:
4374      case OUTER:
4375      case INNER:
4376      case JOIN:
4377      case FETCH:
4378      case IN:
4379      case SET:
4380      case OBJECT:
4381      case IDENTIFIER:
4382        path_component();
4383        break;
4384      default:
4385        jj_la1[102] = jj_gen;
4386        jj_consume_token(-1);
4387        throw new ParseException();
4388      }
4389    }
4390  }
4391
4392  final public void entity_bean_expression() throws ParseException {
4393    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4394    case 86:
4395    case 87:
4396      input_parameter();
4397      break;
4398    case NEW:
4399    case ALL:
4400    case ANY:
4401    case EXISTS:
4402    case SOME:
4403    case EMPTY:
4404    case ASC:
4405    case DESC:
4406    case ORDER:
4407    case BY:
4408    case IS:
4409    case MEMBER:
4410    case OF:
4411    case LIKE:
4412    case ESCAPE:
4413    case BETWEEN:
4414    case NULL:
4415    case AVG:
4416    case MIN:
4417    case MAX:
4418    case SUM:
4419    case COUNT:
4420    case OR:
4421    case AND:
4422    case NOT:
4423    case CONCAT:
4424    case SUBSTRING:
4425    case TRIM:
4426    case LOWER:
4427    case UPPER:
4428    case LEADING:
4429    case TRAILING:
4430    case BOTH:
4431    case LENGTH:
4432    case LOCATE:
4433    case ABS:
4434    case SQRT:
4435    case MOD:
4436    case SIZE:
4437    case CURRENT_DATE:
4438    case CURRENT_TIME:
4439    case CURRENT_TIMESTAMP:
4440    case SELECT:
4441    case DISTINCT:
4442    case FROM:
4443    case UPDATE:
4444    case DELETE:
4445    case WHERE:
4446    case GROUP:
4447    case HAVING:
4448    case AS:
4449    case LEFT:
4450    case OUTER:
4451    case INNER:
4452    case JOIN:
4453    case FETCH:
4454    case IN:
4455    case SET:
4456    case OBJECT:
4457    case IDENTIFIER:
4458      entity_bean_value();
4459      break;
4460    default:
4461      jj_la1[103] = jj_gen;
4462      jj_consume_token(-1);
4463      throw new ParseException();
4464    }
4465  }
4466
4467  final public void functions_returning_strings() throws ParseException {
4468    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4469    case CONCAT:
4470      concat();
4471      break;
4472    case SUBSTRING:
4473      substring();
4474      break;
4475    case TRIM:
4476      trim();
4477      break;
4478    case LOWER:
4479      lower();
4480      break;
4481    case UPPER:
4482      upper();
4483      break;
4484    default:
4485      jj_la1[104] = jj_gen;
4486      jj_consume_token(-1);
4487      throw new ParseException();
4488    }
4489  }
4490
4491  final public void concat() throws ParseException {
4492                         /*@bgen(jjtree) Concat */
4493  EJBQLConcat jjtn000 = new EJBQLConcat(JJTCONCAT);
4494  boolean jjtc000 = true;
4495  jjtree.openNodeScope(jjtn000);
4496    try {
4497      jj_consume_token(CONCAT);
4498      jj_consume_token(84);
4499      string_expression();
4500      jj_consume_token(COMMA);
4501      string_expression();
4502      jj_consume_token(85);
4503    } catch (Throwable JavaDoc jjte000) {
4504          if (jjtc000) {
4505            jjtree.clearNodeScope(jjtn000);
4506            jjtc000 = false;
4507          } else {
4508            jjtree.popNode();
4509          }
4510          if (jjte000 instanceof RuntimeException JavaDoc) {
4511            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4512          }
4513          if (jjte000 instanceof ParseException) {
4514            {if (true) throw (ParseException)jjte000;}
4515          }
4516          {if (true) throw (Error JavaDoc)jjte000;}
4517    } finally {
4518          if (jjtc000) {
4519            jjtree.closeNodeScope(jjtn000, true);
4520          }
4521    }
4522  }
4523
4524  final public void substring() throws ParseException {
4525                               /*@bgen(jjtree) Substring */
4526  EJBQLSubstring jjtn000 = new EJBQLSubstring(JJTSUBSTRING);
4527  boolean jjtc000 = true;
4528  jjtree.openNodeScope(jjtn000);
4529    try {
4530      jj_consume_token(SUBSTRING);
4531      jj_consume_token(84);
4532      string_expression();
4533      jj_consume_token(COMMA);
4534      arithmetic_expression();
4535      jj_consume_token(COMMA);
4536      arithmetic_expression();
4537      jj_consume_token(85);
4538    } catch (Throwable JavaDoc jjte000) {
4539          if (jjtc000) {
4540            jjtree.clearNodeScope(jjtn000);
4541            jjtc000 = false;
4542          } else {
4543            jjtree.popNode();
4544          }
4545          if (jjte000 instanceof RuntimeException JavaDoc) {
4546            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4547          }
4548          if (jjte000 instanceof ParseException) {
4549            {if (true) throw (ParseException)jjte000;}
4550          }
4551          {if (true) throw (Error JavaDoc)jjte000;}
4552    } finally {
4553          if (jjtc000) {
4554            jjtree.closeNodeScope(jjtn000, true);
4555          }
4556    }
4557  }
4558
4559  final public void trim() throws ParseException {
4560                     /*@bgen(jjtree) Trim */
4561  EJBQLTrim jjtn000 = new EJBQLTrim(JJTTRIM);
4562  boolean jjtc000 = true;
4563  jjtree.openNodeScope(jjtn000);
4564    try {
4565      jj_consume_token(TRIM);
4566      jj_consume_token(84);
4567      if (jj_2_59(2)) {
4568        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4569        case LEADING:
4570        case TRAILING:
4571        case BOTH:
4572          trim_specification();
4573          break;
4574        default:
4575          jj_la1[105] = jj_gen;
4576          ;
4577        }
4578        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4579        case STRING_LITERAL:
4580          trim_character();
4581          break;
4582        default:
4583          jj_la1[106] = jj_gen;
4584          ;
4585        }
4586        jj_consume_token(FROM);
4587      } else {
4588        ;
4589      }
4590      string_expression();
4591      jj_consume_token(85);
4592    } catch (Throwable JavaDoc jjte000) {
4593          if (jjtc000) {
4594            jjtree.clearNodeScope(jjtn000);
4595            jjtc000 = false;
4596          } else {
4597            jjtree.popNode();
4598          }
4599          if (jjte000 instanceof RuntimeException JavaDoc) {
4600            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4601          }
4602          if (jjte000 instanceof ParseException) {
4603            {if (true) throw (ParseException)jjte000;}
4604          }
4605          {if (true) throw (Error JavaDoc)jjte000;}
4606    } finally {
4607          if (jjtc000) {
4608            jjtree.closeNodeScope(jjtn000, true);
4609          }
4610    }
4611  }
4612
4613  final public void lower() throws ParseException {
4614                       /*@bgen(jjtree) Lower */
4615  EJBQLLower jjtn000 = new EJBQLLower(JJTLOWER);
4616  boolean jjtc000 = true;
4617  jjtree.openNodeScope(jjtn000);
4618    try {
4619      jj_consume_token(LOWER);
4620      jj_consume_token(84);
4621      string_expression();
4622      jj_consume_token(85);
4623    } catch (Throwable JavaDoc jjte000) {
4624          if (jjtc000) {
4625            jjtree.clearNodeScope(jjtn000);
4626            jjtc000 = false;
4627          } else {
4628            jjtree.popNode();
4629          }
4630          if (jjte000 instanceof RuntimeException JavaDoc) {
4631            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4632          }
4633          if (jjte000 instanceof ParseException) {
4634            {if (true) throw (ParseException)jjte000;}
4635          }
4636          {if (true) throw (Error JavaDoc)jjte000;}
4637    } finally {
4638          if (jjtc000) {
4639            jjtree.closeNodeScope(jjtn000, true);
4640          }
4641    }
4642  }
4643
4644  final public void upper() throws ParseException {
4645                       /*@bgen(jjtree) Upper */
4646  EJBQLUpper jjtn000 = new EJBQLUpper(JJTUPPER);
4647  boolean jjtc000 = true;
4648  jjtree.openNodeScope(jjtn000);
4649    try {
4650      jj_consume_token(UPPER);
4651      jj_consume_token(84);
4652      string_expression();
4653      jj_consume_token(85);
4654    } catch (Throwable JavaDoc jjte000) {
4655          if (jjtc000) {
4656            jjtree.clearNodeScope(jjtn000);
4657            jjtc000 = false;
4658          } else {
4659            jjtree.popNode();
4660          }
4661          if (jjte000 instanceof RuntimeException JavaDoc) {
4662            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4663          }
4664          if (jjte000 instanceof ParseException) {
4665            {if (true) throw (ParseException)jjte000;}
4666          }
4667          {if (true) throw (Error JavaDoc)jjte000;}
4668    } finally {
4669          if (jjtc000) {
4670            jjtree.closeNodeScope(jjtn000, true);
4671          }
4672    }
4673  }
4674
4675  final public void trim_specification() throws ParseException {
4676    if (jj_2_60(2)) {
4677                        EJBQLTrimLeading jjtn001 = new EJBQLTrimLeading(JJTTRIMLEADING);
4678                        boolean jjtc001 = true;
4679                        jjtree.openNodeScope(jjtn001);
4680      try {
4681        jj_consume_token(LEADING);
4682      } finally {
4683                        if (jjtc001) {
4684                          jjtree.closeNodeScope(jjtn001, true);
4685                        }
4686      }
4687    } else {
4688      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4689      case TRAILING:
4690                                                   EJBQLTrimTrailing jjtn002 = new EJBQLTrimTrailing(JJTTRIMTRAILING);
4691                                                   boolean jjtc002 = true;
4692                                                   jjtree.openNodeScope(jjtn002);
4693        try {
4694          jj_consume_token(TRAILING);
4695        } finally {
4696                                                   if (jjtc002) {
4697                                                     jjtree.closeNodeScope(jjtn002, true);
4698                                                   }
4699        }
4700        break;
4701      case BOTH:
4702                                                                                EJBQLTrimBoth jjtn003 = new EJBQLTrimBoth(JJTTRIMBOTH);
4703                                                                                boolean jjtc003 = true;
4704                                                                                jjtree.openNodeScope(jjtn003);
4705        try {
4706          jj_consume_token(BOTH);
4707        } finally {
4708                                                                                if (jjtc003) {
4709                                                                                  jjtree.closeNodeScope(jjtn003, true);
4710                                                                                }
4711        }
4712        break;
4713      default:
4714        jj_la1[107] = jj_gen;
4715        jj_consume_token(-1);
4716        throw new ParseException();
4717      }
4718    }
4719  }
4720
4721  final public void functions_returning_numerics() throws ParseException {
4722    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4723    case LENGTH:
4724      length();
4725      break;
4726    case LOCATE:
4727      locate();
4728      break;
4729    case ABS:
4730      abs();
4731      break;
4732    case SQRT:
4733      sqrt();
4734      break;
4735    case MOD:
4736      mod();
4737      break;
4738    case SIZE:
4739      size();
4740      break;
4741    default:
4742      jj_la1[108] = jj_gen;
4743      jj_consume_token(-1);
4744      throw new ParseException();
4745    }
4746  }
4747
4748  final public void length() throws ParseException {
4749                         /*@bgen(jjtree) Length */
4750  EJBQLLength jjtn000 = new EJBQLLength(JJTLENGTH);
4751  boolean jjtc000 = true;
4752  jjtree.openNodeScope(jjtn000);
4753    try {
4754      jj_consume_token(LENGTH);
4755      jj_consume_token(84);
4756      string_expression();
4757      jj_consume_token(85);
4758    } catch (Throwable JavaDoc jjte000) {
4759          if (jjtc000) {
4760            jjtree.clearNodeScope(jjtn000);
4761            jjtc000 = false;
4762          } else {
4763            jjtree.popNode();
4764          }
4765          if (jjte000 instanceof RuntimeException JavaDoc) {
4766            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4767          }
4768          if (jjte000 instanceof ParseException) {
4769            {if (true) throw (ParseException)jjte000;}
4770          }
4771          {if (true) throw (Error JavaDoc)jjte000;}
4772    } finally {
4773          if (jjtc000) {
4774            jjtree.closeNodeScope(jjtn000, true);
4775          }
4776    }
4777  }
4778
4779  final public void locate() throws ParseException {
4780                         /*@bgen(jjtree) Locate */
4781  EJBQLLocate jjtn000 = new EJBQLLocate(JJTLOCATE);
4782  boolean jjtc000 = true;
4783  jjtree.openNodeScope(jjtn000);
4784    try {
4785      jj_consume_token(LOCATE);
4786      jj_consume_token(84);
4787      string_expression();
4788      jj_consume_token(COMMA);
4789      string_expression();
4790      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4791      case COMMA:
4792        jj_consume_token(COMMA);
4793        arithmetic_expression();
4794        break;
4795      default:
4796        jj_la1[109] = jj_gen;
4797        ;
4798      }
4799      jj_consume_token(85);
4800    } catch (Throwable JavaDoc jjte000) {
4801          if (jjtc000) {
4802            jjtree.clearNodeScope(jjtn000);
4803            jjtc000 = false;
4804          } else {
4805            jjtree.popNode();
4806          }
4807          if (jjte000 instanceof RuntimeException JavaDoc) {
4808            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4809          }
4810          if (jjte000 instanceof ParseException) {
4811            {if (true) throw (ParseException)jjte000;}
4812          }
4813          {if (true) throw (Error JavaDoc)jjte000;}
4814    } finally {
4815          if (jjtc000) {
4816            jjtree.closeNodeScope(jjtn000, true);
4817          }
4818    }
4819  }
4820
4821  final public void abs() throws ParseException {
4822                   /*@bgen(jjtree) Abs */
4823  EJBQLAbs jjtn000 = new EJBQLAbs(JJTABS);
4824  boolean jjtc000 = true;
4825  jjtree.openNodeScope(jjtn000);
4826    try {
4827      jj_consume_token(ABS);
4828      jj_consume_token(84);
4829      arithmetic_expression();
4830      jj_consume_token(85);
4831    } catch (Throwable JavaDoc jjte000) {
4832          if (jjtc000) {
4833            jjtree.clearNodeScope(jjtn000);
4834            jjtc000 = false;
4835          } else {
4836            jjtree.popNode();
4837          }
4838          if (jjte000 instanceof RuntimeException JavaDoc) {
4839            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4840          }
4841          if (jjte000 instanceof ParseException) {
4842            {if (true) throw (ParseException)jjte000;}
4843          }
4844          {if (true) throw (Error JavaDoc)jjte000;}
4845    } finally {
4846          if (jjtc000) {
4847            jjtree.closeNodeScope(jjtn000, true);
4848          }
4849    }
4850  }
4851
4852  final public void sqrt() throws ParseException {
4853                     /*@bgen(jjtree) Sqrt */
4854  EJBQLSqrt jjtn000 = new EJBQLSqrt(JJTSQRT);
4855  boolean jjtc000 = true;
4856  jjtree.openNodeScope(jjtn000);
4857    try {
4858      jj_consume_token(SQRT);
4859      jj_consume_token(84);
4860      arithmetic_expression();
4861      jj_consume_token(85);
4862    } catch (Throwable JavaDoc jjte000) {
4863          if (jjtc000) {
4864            jjtree.clearNodeScope(jjtn000);
4865            jjtc000 = false;
4866          } else {
4867            jjtree.popNode();
4868          }
4869          if (jjte000 instanceof RuntimeException JavaDoc) {
4870            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4871          }
4872          if (jjte000 instanceof ParseException) {
4873            {if (true) throw (ParseException)jjte000;}
4874          }
4875          {if (true) throw (Error JavaDoc)jjte000;}
4876    } finally {
4877          if (jjtc000) {
4878            jjtree.closeNodeScope(jjtn000, true);
4879          }
4880    }
4881  }
4882
4883  final public void mod() throws ParseException {
4884                   /*@bgen(jjtree) Mod */
4885  EJBQLMod jjtn000 = new EJBQLMod(JJTMOD);
4886  boolean jjtc000 = true;
4887  jjtree.openNodeScope(jjtn000);
4888    try {
4889      jj_consume_token(MOD);
4890      jj_consume_token(84);
4891      arithmetic_expression();
4892      jj_consume_token(COMMA);
4893      arithmetic_expression();
4894      jj_consume_token(85);
4895    } catch (Throwable JavaDoc jjte000) {
4896          if (jjtc000) {
4897            jjtree.clearNodeScope(jjtn000);
4898            jjtc000 = false;
4899          } else {
4900            jjtree.popNode();
4901          }
4902          if (jjte000 instanceof RuntimeException JavaDoc) {
4903            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4904          }
4905          if (jjte000 instanceof ParseException) {
4906            {if (true) throw (ParseException)jjte000;}
4907          }
4908          {if (true) throw (Error JavaDoc)jjte000;}
4909    } finally {
4910          if (jjtc000) {
4911            jjtree.closeNodeScope(jjtn000, true);
4912          }
4913    }
4914  }
4915
4916  final public void size() throws ParseException {
4917                     /*@bgen(jjtree) Size */
4918  EJBQLSize jjtn000 = new EJBQLSize(JJTSIZE);
4919  boolean jjtc000 = true;
4920  jjtree.openNodeScope(jjtn000);
4921    try {
4922      jj_consume_token(SIZE);
4923      jj_consume_token(84);
4924      path();
4925      jj_consume_token(85);
4926    } catch (Throwable JavaDoc jjte000) {
4927          if (jjtc000) {
4928            jjtree.clearNodeScope(jjtn000);
4929            jjtc000 = false;
4930          } else {
4931            jjtree.popNode();
4932          }
4933          if (jjte000 instanceof RuntimeException JavaDoc) {
4934            {if (true) throw (RuntimeException JavaDoc)jjte000;}
4935          }
4936          if (jjte000 instanceof ParseException) {
4937            {if (true) throw (ParseException)jjte000;}
4938          }
4939          {if (true) throw (Error JavaDoc)jjte000;}
4940    } finally {
4941          if (jjtc000) {
4942            jjtree.closeNodeScope(jjtn000, true);
4943          }
4944    }
4945  }
4946
4947  final public void functions_returning_datetime() throws ParseException {
4948    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4949    case CURRENT_DATE:
4950           EJBQLCurrentDate jjtn001 = new EJBQLCurrentDate(JJTCURRENTDATE);
4951           boolean jjtc001 = true;
4952           jjtree.openNodeScope(jjtn001);
4953      try {
4954        jj_consume_token(CURRENT_DATE);
4955      } finally {
4956           if (jjtc001) {
4957             jjtree.closeNodeScope(jjtn001, true);
4958           }
4959      }
4960      break;
4961    case CURRENT_TIME:
4962             EJBQLCurrentTime jjtn002 = new EJBQLCurrentTime(JJTCURRENTTIME);
4963             boolean jjtc002 = true;
4964             jjtree.openNodeScope(jjtn002);
4965      try {
4966        jj_consume_token(CURRENT_TIME);
4967      } finally {
4968             if (jjtc002) {
4969               jjtree.closeNodeScope(jjtn002, true);
4970             }
4971      }
4972      break;
4973    case CURRENT_TIMESTAMP:
4974             EJBQLCurrentTimestamp jjtn003 = new EJBQLCurrentTimestamp(JJTCURRENTTIMESTAMP);
4975             boolean jjtc003 = true;
4976             jjtree.openNodeScope(jjtn003);
4977      try {
4978        jj_consume_token(CURRENT_TIMESTAMP);
4979      } finally {
4980             if (jjtc003) {
4981               jjtree.closeNodeScope(jjtn003, true);
4982             }
4983      }
4984      break;
4985    default:
4986      jj_la1[110] = jj_gen;
4987      jj_consume_token(-1);
4988      throw new ParseException();
4989    }
4990  }
4991
4992  final public void orderby_clause() throws ParseException {
4993                                  /*@bgen(jjtree) OrderBy */
4994  EJBQLOrderBy jjtn000 = new EJBQLOrderBy(JJTORDERBY);
4995  boolean jjtc000 = true;
4996  jjtree.openNodeScope(jjtn000);
4997    try {
4998      jj_consume_token(ORDER);
4999      jj_consume_token(BY);
5000      orderby_item();
5001      label_16:
5002      while (true) {
5003        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5004        case COMMA:
5005          ;
5006          break;
5007        default:
5008          jj_la1[111] = jj_gen;
5009          break label_16;
5010        }
5011        jj_consume_token(COMMA);
5012        orderby_item();
5013      }
5014    } catch (Throwable JavaDoc jjte000) {
5015          if (jjtc000) {
5016            jjtree.clearNodeScope(jjtn000);
5017            jjtc000 = false;
5018          } else {
5019            jjtree.popNode();
5020          }
5021          if (jjte000 instanceof RuntimeException JavaDoc) {
5022            {if (true) throw (RuntimeException JavaDoc)jjte000;}
5023          }
5024          if (jjte000 instanceof ParseException) {
5025            {if (true) throw (ParseException)jjte000;}
5026          }
5027          {if (true) throw (Error JavaDoc)jjte000;}
5028    } finally {
5029          if (jjtc000) {
5030            jjtree.closeNodeScope(jjtn000, true);
5031          }
5032    }
5033  }
5034
5035  final public void orderby_item() throws ParseException {
5036                                    /*@bgen(jjtree) OrderByItem */
5037  EJBQLOrderByItem jjtn000 = new EJBQLOrderByItem(JJTORDERBYITEM);
5038  boolean jjtc000 = true;
5039  jjtree.openNodeScope(jjtn000);
5040    try {
5041      path();
5042      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5043      case ASC:
5044      case DESC:
5045        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5046        case ASC:
5047                   EJBQLAscending jjtn001 = new EJBQLAscending(JJTASCENDING);
5048                   boolean jjtc001 = true;
5049                   jjtree.openNodeScope(jjtn001);
5050          try {
5051            jj_consume_token(ASC);
5052          } finally {
5053                   if (jjtc001) {
5054                     jjtree.closeNodeScope(jjtn001, true);
5055                   }
5056          }
5057          break;
5058        case DESC:
5059                                      EJBQLDescending jjtn002 = new EJBQLDescending(JJTDESCENDING);
5060                                      boolean jjtc002 = true;
5061                                      jjtree.openNodeScope(jjtn002);
5062          try {
5063            jj_consume_token(DESC);
5064          } finally {
5065                                      if (jjtc002) {
5066                                        jjtree.closeNodeScope(jjtn002, true);
5067                                      }
5068          }
5069          break;
5070        default:
5071          jj_la1[112] = jj_gen;
5072          jj_consume_token(-1);
5073          throw new ParseException();
5074        }
5075        break;
5076      default:
5077        jj_la1[113] = jj_gen;
5078        ;
5079      }
5080    } catch (Throwable JavaDoc jjte000) {
5081          if (jjtc000) {
5082            jjtree.clearNodeScope(jjtn000);
5083            jjtc000 = false;
5084          } else {
5085            jjtree.popNode();
5086          }
5087          if (jjte000 instanceof RuntimeException JavaDoc) {
5088            {if (true) throw (RuntimeException JavaDoc)jjte000;}
5089          }
5090          if (jjte000 instanceof ParseException) {
5091            {if (true) throw (ParseException)jjte000;}
5092          }
5093          {if (true) throw (Error JavaDoc)jjte000;}
5094    } finally {
5095          if (jjtc000) {
5096            jjtree.closeNodeScope(jjtn000, true);
5097          }
5098    }
5099  }
5100
5101  final public void abstract_schema_name() throws ParseException {
5102                                                   /*@bgen(jjtree) AbstractSchemaName */
5103  EJBQLAbstractSchemaName jjtn000 = new EJBQLAbstractSchemaName(JJTABSTRACTSCHEMANAME);
5104  boolean jjtc000 = true;
5105  jjtree.openNodeScope(jjtn000);
5106    try {
5107      path_component();
5108      label_17:
5109      while (true) {
5110        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5111        case DOT:
5112          ;
5113          break;
5114        default:
5115          jj_la1[114] = jj_gen;
5116          break label_17;
5117        }
5118        jj_consume_token(DOT);
5119        path_component();
5120      }
5121    } catch (Throwable JavaDoc jjte000) {
5122          if (jjtc000) {
5123            jjtree.clearNodeScope(jjtn000);
5124            jjtc000 = false;
5125          } else {
5126            jjtree.popNode();
5127          }
5128          if (jjte000 instanceof RuntimeException JavaDoc) {
5129            {if (true) throw (RuntimeException JavaDoc)jjte000;}
5130          }
5131          if (jjte000 instanceof ParseException) {
5132            {if (true) throw (ParseException)jjte000;}
5133          }
5134          {if (true) throw (Error JavaDoc)jjte000;}
5135    } finally {
5136          if (jjtc000) {
5137            jjtree.closeNodeScope(jjtn000, true);
5138          }
5139    }
5140  }
5141
5142  final public void tok() throws ParseException {
5143 /*@bgen(jjtree) Tok */
5144  EJBQLTok jjtn000 = new EJBQLTok(JJTTOK);
5145  boolean jjtc000 = true;
5146  jjtree.openNodeScope(jjtn000);Token t;
5147    try {
5148      t = jj_consume_token(IDENTIFIER);
5149                           jjtree.closeNodeScope(jjtn000, true);
5150                           jjtc000 = false;
5151                           jjtn000.setText (t.image);
5152    } finally {
5153          if (jjtc000) {
5154            jjtree.closeNodeScope(jjtn000, true);
5155          }
5156    }
5157  }
5158
5159  final public void identification_variable() throws ParseException {
5160 /*@bgen(jjtree) Identifier */
5161  EJBQLIdentifier jjtn000 = new EJBQLIdentifier(JJTIDENTIFIER);
5162  boolean jjtc000 = true;
5163  jjtree.openNodeScope(jjtn000);Token t;
5164    try {
5165      t = jj_consume_token(IDENTIFIER);
5166                           jjtree.closeNodeScope(jjtn000, true);
5167                           jjtc000 = false;
5168                           jjtn000.setText (t.image);
5169    } finally {
5170          if (jjtc000) {
5171            jjtree.closeNodeScope(jjtn000, true);
5172          }
5173    }
5174  }
5175
5176  final public void path_component() throws ParseException {
5177 /*@bgen(jjtree) IdentificationVariable */
5178  EJBQLIdentificationVariable jjtn000 = new EJBQLIdentificationVariable(JJTIDENTIFICATIONVARIABLE);
5179  boolean jjtc000 = true;
5180  jjtree.openNodeScope(jjtn000);Token t;
5181    try {
5182      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5183      case NEW:
5184        t = jj_consume_token(NEW);
5185        break;
5186      case ALL:
5187        t = jj_consume_token(ALL);
5188        break;
5189      case ANY:
5190        t = jj_consume_token(ANY);
5191        break;
5192      case EXISTS:
5193        t = jj_consume_token(EXISTS);
5194        break;
5195      case SOME:
5196        t = jj_consume_token(SOME);
5197        break;
5198      case EMPTY:
5199        t = jj_consume_token(EMPTY);
5200        break;
5201      case ASC:
5202        t = jj_consume_token(ASC);
5203        break;
5204      case DESC:
5205        t = jj_consume_token(DESC);
5206        break;
5207      case ORDER:
5208        t = jj_consume_token(ORDER);
5209        break;
5210      case IS:
5211        t = jj_consume_token(IS);
5212        break;
5213      case MEMBER:
5214        t = jj_consume_token(MEMBER);
5215        break;
5216      case OF:
5217        t = jj_consume_token(OF);
5218        break;
5219      case LIKE:
5220        t = jj_consume_token(LIKE);
5221        break;
5222      case ESCAPE:
5223        t = jj_consume_token(ESCAPE);
5224        break;
5225      case BETWEEN:
5226        t = jj_consume_token(BETWEEN);
5227        break;
5228      case NULL:
5229        t = jj_consume_token(NULL);
5230        break;
5231      case AVG:
5232        t = jj_consume_token(AVG);
5233        break;
5234      case MIN:
5235        t = jj_consume_token(MIN);
5236        break;
5237      case MAX:
5238        t = jj_consume_token(MAX);
5239        break;
5240      case SUM:
5241        t = jj_consume_token(SUM);
5242        break;
5243      case COUNT:
5244        t = jj_consume_token(COUNT);
5245        break;
5246      case OR:
5247        t = jj_consume_token(OR);
5248        break;
5249      case AND:
5250        t = jj_consume_token(AND);
5251        break;
5252      case NOT:
5253        t = jj_consume_token(NOT);
5254        break;
5255      case CONCAT:
5256        t = jj_consume_token(CONCAT);
5257        break;
5258      case SUBSTRING:
5259        t = jj_consume_token(SUBSTRING);
5260        break;
5261      case TRIM:
5262        t = jj_consume_token(TRIM);
5263        break;
5264      case LOWER:
5265        t = jj_consume_token(LOWER);
5266        break;
5267      case UPPER:
5268        t = jj_consume_token(UPPER);
5269        break;
5270      case LEADING:
5271        t = jj_consume_token(LEADING);
5272        break;
5273      case TRAILING:
5274        t = jj_consume_token(TRAILING);
5275        break;
5276      case BOTH:
5277        t = jj_consume_token(BOTH);
5278        break;
5279      case LENGTH:
5280        t = jj_consume_token(LENGTH);
5281        break;
5282      case LOCATE:
5283        t = jj_consume_token(LOCATE);
5284        break;
5285      case ABS:
5286        t = jj_consume_token(ABS);
5287        break;
5288      case SQRT:
5289        t = jj_consume_token(SQRT);
5290        break;
5291      case MOD:
5292        t = jj_consume_token(MOD);
5293        break;
5294      case SIZE:
5295        t = jj_consume_token(SIZE);
5296        break;
5297      case CURRENT_DATE:
5298        t = jj_consume_token(CURRENT_DATE);
5299        break;
5300      case CURRENT_TIME:
5301        t = jj_consume_token(CURRENT_TIME);
5302        break;
5303      case CURRENT_TIMESTAMP:
5304        t = jj_consume_token(CURRENT_TIMESTAMP);
5305        break;
5306      case SELECT:
5307        t = jj_consume_token(SELECT);
5308        break;
5309      case DISTINCT:
5310        t = jj_consume_token(DISTINCT);
5311        break;
5312      case FROM:
5313        t = jj_consume_token(FROM);
5314        break;
5315      case UPDATE:
5316        t = jj_consume_token(UPDATE);
5317        break;
5318      case DELETE:
5319        t = jj_consume_token(DELETE);
5320        break;
5321      case WHERE:
5322        t = jj_consume_token(WHERE);
5323        break;
5324      case GROUP:
5325        t = jj_consume_token(GROUP);
5326        break;
5327      case BY:
5328        t = jj_consume_token(BY);
5329        break;
5330      case HAVING:
5331        t = jj_consume_token(HAVING);
5332        break;
5333      case AS:
5334        t = jj_consume_token(AS);
5335        break;
5336      case LEFT:
5337        t = jj_consume_token(LEFT);
5338        break;
5339      case OUTER:
5340        t = jj_consume_token(OUTER);
5341        break;
5342      case INNER:
5343        t = jj_consume_token(INNER);
5344        break;
5345      case JOIN:
5346        t = jj_consume_token(JOIN);
5347        break;
5348      case FETCH:
5349        t = jj_consume_token(FETCH);
5350        break;
5351      case IN:
5352        t = jj_consume_token(IN);
5353        break;
5354      case SET:
5355        t = jj_consume_token(SET);
5356        break;
5357      case OBJECT:
5358        t = jj_consume_token(OBJECT);
5359        break;
5360      case IDENTIFIER:
5361        t = jj_consume_token(IDENTIFIER);
5362        break;
5363      default:
5364        jj_la1[115] = jj_gen;
5365        jj_consume_token(-1);
5366        throw new ParseException();
5367      }
5368        jjtree.closeNodeScope(jjtn000, true);
5369        jjtc000 = false;
5370        jjtn000.setText (t.image);
5371    } finally {
5372          if (jjtc000) {
5373            jjtree.closeNodeScope(jjtn000, true);
5374          }
5375    }
5376  }
5377
5378  final public void numeric_literal() throws ParseException {
5379    if (jj_2_61(2147483647)) {
5380      decimal_literal();
5381    } else {
5382      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5383      case PLUS:
5384      case MINUS:
5385      case INTEGER_LITERAL:
5386        integer_literal();
5387        break;
5388      default:
5389        jj_la1[116] = jj_gen;
5390        jj_consume_token(-1);
5391        throw new ParseException();
5392      }
5393    }
5394  }
5395
5396  final public void integer_literal() throws ParseException {
5397 /*@bgen(jjtree) IntegerLiteral */
5398  EJBQLIntegerLiteral jjtn000 = new EJBQLIntegerLiteral(JJTINTEGERLITERAL);
5399  boolean jjtc000 = true;
5400  jjtree.openNodeScope(jjtn000);Token t;
5401    try {
5402      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5403      case PLUS:
5404      case MINUS:
5405        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5406        case PLUS:
5407          jj_consume_token(PLUS);
5408          break;
5409        case MINUS:
5410          negative();
5411          break;
5412        default:
5413          jj_la1[117] = jj_gen;
5414          jj_consume_token(-1);
5415          throw new ParseException();
5416        }
5417        break;
5418      default:
5419        jj_la1[118] = jj_gen;
5420        ;
5421      }
5422      t = jj_consume_token(INTEGER_LITERAL);
5423                                                      jjtree.closeNodeScope(jjtn000, true);
5424                                                      jjtc000 = false;
5425                                                      jjtn000.setText (t.image);
5426    } catch (Throwable JavaDoc jjte000) {
5427          if (jjtc000) {
5428            jjtree.clearNodeScope(jjtn000);
5429            jjtc000 = false;
5430          } else {
5431            jjtree.popNode();
5432          }
5433          if (jjte000 instanceof RuntimeException JavaDoc) {
5434            {if (true) throw (RuntimeException JavaDoc)jjte000;}
5435          }
5436          if (jjte000 instanceof ParseException) {
5437            {if (true) throw (ParseException)jjte000;}
5438          }
5439          {if (true) throw (Error JavaDoc)jjte000;}
5440    } finally {
5441          if (jjtc000) {
5442            jjtree.closeNodeScope(jjtn000, true);
5443          }
5444    }
5445  }
5446
5447  final public void decimal_literal() throws ParseException {
5448 /*@bgen(jjtree) DecimalLiteral */
5449  EJBQLDecimalLiteral jjtn000 = new EJBQLDecimalLiteral(JJTDECIMALLITERAL);
5450  boolean jjtc000 = true;
5451  jjtree.openNodeScope(jjtn000);Token t;
5452    try {
5453      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5454      case PLUS:
5455      case MINUS:
5456        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5457        case PLUS:
5458          jj_consume_token(PLUS);
5459          break;
5460        case MINUS:
5461          negative();
5462          break;
5463        default:
5464          jj_la1[119] = jj_gen;
5465          jj_consume_token(-1);
5466          throw new ParseException();
5467        }
5468        break;
5469      default:
5470        jj_la1[120] = jj_gen;
5471        ;
5472      }
5473      t = jj_consume_token(DECIMAL_LITERAL);
5474                                                       jjtree.closeNodeScope(jjtn000, true);
5475                                                       jjtc000 = false;
5476                                                       jjtn000.setText (t.image);
5477    } catch (Throwable JavaDoc jjte000) {
5478           if (jjtc000) {
5479             jjtree.clearNodeScope(jjtn000);
5480             jjtc000 = false;
5481           } else {
5482             jjtree.popNode();
5483           }
5484           if (jjte000 instanceof RuntimeException JavaDoc) {
5485             {if (true) throw (RuntimeException JavaDoc)jjte000;}
5486           }
5487           if (jjte000 instanceof ParseException) {
5488             {if (true) throw (ParseException)jjte000;}
5489           }
5490           {if (true) throw (Error JavaDoc)jjte000;}
5491    } finally {
5492           if (jjtc000) {
5493             jjtree.closeNodeScope(jjtn000, true);
5494           }
5495    }
5496  }
5497
5498  final public void boolean_literal() throws ParseException {
5499 /*@bgen(jjtree) BooleanLiteral */
5500  EJBQLBooleanLiteral jjtn000 = new EJBQLBooleanLiteral(JJTBOOLEANLITERAL);
5501  boolean jjtc000 = true;
5502  jjtree.openNodeScope(jjtn000);Token t;
5503    try {
5504      t = jj_consume_token(BOOLEAN_LITERAL);
5505                                jjtree.closeNodeScope(jjtn000, true);
5506                                jjtc000 = false;
5507                                jjtn000.setText (t.image);
5508    } finally {
5509          if (jjtc000) {
5510            jjtree.closeNodeScope(jjtn000, true);
5511          }
5512    }
5513  }
5514
5515  final public void string_literal() throws ParseException {
5516 /*@bgen(jjtree) StringLiteral */
5517  EJBQLStringLiteral jjtn000 = new EJBQLStringLiteral(JJTSTRINGLITERAL);
5518  boolean jjtc000 = true;
5519  jjtree.openNodeScope(jjtn000);Token t;
5520    try {
5521      t = jj_consume_token(STRING_LITERAL);
5522                               jjtree.closeNodeScope(jjtn000, true);
5523                               jjtc000 = false;
5524                               jjtn000.setText (t.image);
5525    } finally {
5526          if (jjtc000) {
5527            jjtree.closeNodeScope(jjtn000, true);
5528          }
5529    }
5530  }
5531
5532  final public void input_parameter() throws ParseException {
5533    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5534    case 86:
5535      named_input_parameter();
5536      break;
5537    case 87:
5538      positional_input_parameter();
5539      break;
5540    default:
5541      jj_la1[121] = jj_gen;
5542      jj_consume_token(-1);
5543      throw new ParseException();
5544    }
5545  }
5546
5547  final public void named_input_parameter() throws ParseException {
5548 /*@bgen(jjtree) NamedInputParameter */
5549  EJBQLNamedInputParameter jjtn000 = new EJBQLNamedInputParameter(JJTNAMEDINPUTPARAMETER);
5550  boolean jjtc000 = true;
5551  jjtree.openNodeScope(jjtn000);Token t;
5552    try {
5553      jj_consume_token(86);
5554      t = jj_consume_token(IDENTIFIER);
5555                               jjtree.closeNodeScope(jjtn000, true);
5556                               jjtc000 = false;
5557                               jjtn000.setText (t.image);
5558    } finally {
5559          if (jjtc000) {
5560            jjtree.closeNodeScope(jjtn000, true);
5561          }
5562    }
5563  }
5564
5565  final public void positional_input_parameter() throws ParseException {
5566 /*@bgen(jjtree) PositionalInputParameter */
5567  EJBQLPositionalInputParameter jjtn000 = new EJBQLPositionalInputParameter(JJTPOSITIONALINPUTPARAMETER);
5568  boolean jjtc000 = true;
5569  jjtree.openNodeScope(jjtn000);Token t;
5570    try {
5571      jj_consume_token(87);
5572      t = jj_consume_token(INTEGER_LITERAL);
5573                                    jjtree.closeNodeScope(jjtn000, true);
5574                                    jjtc000 = false;
5575                                    jjtn000.setText (t.image);
5576    } finally {
5577          if (jjtc000) {
5578            jjtree.closeNodeScope(jjtn000, true);
5579          }
5580    }
5581  }
5582
5583  final public void pattern_value() throws ParseException {
5584                                      /*@bgen(jjtree) PatternValue */
5585  EJBQLPatternValue jjtn000 = new EJBQLPatternValue(JJTPATTERNVALUE);
5586  boolean jjtc000 = true;
5587  jjtree.openNodeScope(jjtn000);
5588    try {
5589      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5590      case 86:
5591      case 87:
5592        input_parameter();
5593        break;
5594      case STRING_LITERAL:
5595        string_literal();
5596        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5597        case ESCAPE:
5598          jj_consume_token(ESCAPE);
5599                     EJBQLEscapeCharacter jjtn001 = new EJBQLEscapeCharacter(JJTESCAPECHARACTER);
5600                     boolean jjtc001 = true;
5601                     jjtree.openNodeScope(jjtn001);
5602          try {
5603            escape_character();
5604          } catch (Throwable JavaDoc jjte001) {
5605                     if (jjtc001) {
5606                       jjtree.clearNodeScope(jjtn001);
5607                       jjtc001 = false;
5608                     } else {
5609                       jjtree.popNode();
5610                     }
5611                     if (jjte001 instanceof RuntimeException JavaDoc) {
5612                       {if (true) throw (RuntimeException JavaDoc)jjte001;}
5613                     }
5614                     if (jjte001 instanceof ParseException) {
5615                       {if (true) throw (ParseException)jjte001;}
5616                     }
5617                     {if (true) throw (Error JavaDoc)jjte001;}
5618          } finally {
5619                     if (jjtc001) {
5620                       jjtree.closeNodeScope(jjtn001, true);
5621                     }
5622          }
5623          break;
5624        default:
5625          jj_la1[122] = jj_gen;
5626          ;
5627        }
5628        break;
5629      default:
5630        jj_la1[123] = jj_gen;
5631        jj_consume_token(-1);
5632        throw new ParseException();
5633      }
5634    } catch (Throwable JavaDoc jjte000) {
5635          if (jjtc000) {
5636            jjtree.clearNodeScope(jjtn000);
5637            jjtc000 = false;
5638          } else {
5639            jjtree.popNode();
5640          }
5641          if (jjte000 instanceof RuntimeException JavaDoc) {
5642            {if (true) throw (RuntimeException JavaDoc)jjte000;}
5643          }
5644          if (jjte000 instanceof ParseException) {
5645            {if (true) throw (ParseException)jjte000;}
5646          }
5647          {if (true) throw (Error JavaDoc)jjte000;}
5648    } finally {
5649          if (jjtc000) {
5650            jjtree.closeNodeScope(jjtn000, true);
5651          }
5652    }
5653  }
5654
5655  final public void escape_character() throws ParseException {
5656 /*@bgen(jjtree) EscapeCharacter */
5657  EJBQLEscapeCharacter jjtn000 = new EJBQLEscapeCharacter(JJTESCAPECHARACTER);
5658  boolean jjtc000 = true;
5659  jjtree.openNodeScope(jjtn000);Token t;
5660    try {
5661      t = jj_consume_token(STRING_LITERAL);
5662                               jjtree.closeNodeScope(jjtn000, true);
5663                               jjtc000 = false;
5664                               jjtn000.setText (t.image);
5665    } finally {
5666          if (jjtc000) {
5667            jjtree.closeNodeScope(jjtn000, true);
5668          }
5669    }
5670  }
5671
5672  final public void trim_character() throws ParseException {
5673 /*@bgen(jjtree) TrimCharacter */
5674  EJBQLTrimCharacter jjtn000 = new EJBQLTrimCharacter(JJTTRIMCHARACTER);
5675  boolean jjtc000 = true;
5676  jjtree.openNodeScope(jjtn000);Token t;
5677    try {
5678      t = jj_consume_token(STRING_LITERAL);
5679                               jjtree.closeNodeScope(jjtn000, true);
5680                               jjtc000 = false;
5681                               jjtn000.setText (t.image);
5682    } finally {
5683          if (jjtc000) {
5684            jjtree.closeNodeScope(jjtn000, true);
5685          }
5686    }
5687  }
5688
5689  final public void EQ() throws ParseException {
5690                     /*@bgen(jjtree) Equals */
5691  EJBQLEquals jjtn000 = new EJBQLEquals(JJTEQUALS);
5692  boolean jjtc000 = true;
5693  jjtree.openNodeScope(jjtn000);
5694    try {
5695      jj_consume_token(EQ);
5696    } finally {
5697          if (jjtc000) {
5698            jjtree.closeNodeScope(jjtn000, true);
5699          }
5700    }
5701  }
5702
5703  final public void NE() throws ParseException {
5704                        /*@bgen(jjtree) NotEquals */
5705  EJBQLNotEquals jjtn000 = new EJBQLNotEquals(JJTNOTEQUALS);
5706  boolean jjtc000 = true;
5707  jjtree.openNodeScope(jjtn000);
5708    try {
5709      jj_consume_token(NE);
5710    } finally {
5711          if (jjtc000) {
5712            jjtree.closeNodeScope(jjtn000, true);
5713          }
5714    }
5715  }
5716
5717  final public void GT() throws ParseException {
5718                          /*@bgen(jjtree) GreaterThan */
5719  EJBQLGreaterThan jjtn000 = new EJBQLGreaterThan(JJTGREATERTHAN);
5720  boolean jjtc000 = true;
5721  jjtree.openNodeScope(jjtn000);
5722    try {
5723      jj_consume_token(GT);
5724    } finally {
5725          if (jjtc000) {
5726            jjtree.closeNodeScope(jjtn000, true);
5727          }
5728    }
5729  }
5730
5731  final public void GE() throws ParseException {
5732                             /*@bgen(jjtree) GreaterOrEqual */
5733  EJBQLGreaterOrEqual jjtn000 = new EJBQLGreaterOrEqual(JJTGREATEROREQUAL);
5734  boolean jjtc000 = true;
5735  jjtree.openNodeScope(jjtn000);
5736    try {
5737      jj_consume_token(GE);
5738    } finally {
5739          if (jjtc000) {
5740            jjtree.closeNodeScope(jjtn000, true);
5741          }
5742    }
5743  }
5744
5745  final public void LT() throws ParseException {
5746                       /*@bgen(jjtree) LessThan */
5747  EJBQLLessThan jjtn000 = new EJBQLLessThan(JJTLESSTHAN);
5748  boolean jjtc000 = true;
5749  jjtree.openNodeScope(jjtn000);
5750    try {
5751      jj_consume_token(LT);
5752    } finally {
5753          if (jjtc000) {
5754            jjtree.closeNodeScope(jjtn000, true);
5755          }
5756    }
5757  }
5758
5759  final public void LE() throws ParseException {
5760                          /*@bgen(jjtree) LessOrEqual */
5761  EJBQLLessOrEqual jjtn000 = new EJBQLLessOrEqual(JJTLESSOREQUAL);
5762  boolean jjtc000 = true;
5763  jjtree.openNodeScope(jjtn000);
5764    try {
5765      jj_consume_token(LE);
5766    } finally {
5767          if (jjtc000) {
5768            jjtree.closeNodeScope(jjtn000, true);
5769          }
5770    }
5771  }
5772
5773  final private boolean jj_2_1(int xla) {
5774    jj_la = xla; jj_lastpos = jj_scanpos = token;
5775    try { return !jj_3_1(); }
5776    catch(LookaheadSuccess ls) { return true; }
5777    finally { jj_save(0, xla); }
5778  }
5779
5780  final private boolean jj_2_2(int xla) {
5781    jj_la = xla; jj_lastpos = jj_scanpos = token;
5782    try { return !jj_3_2(); }
5783    catch(LookaheadSuccess ls) { return true; }
5784    finally { jj_save(1, xla); }
5785  }
5786
5787  final private boolean jj_2_3(int xla) {
5788    jj_la = xla; jj_lastpos = jj_scanpos = token;
5789    try { return !jj_3_3(); }
5790    catch(LookaheadSuccess ls) { return true; }
5791    finally { jj_save(2, xla); }
5792  }
5793
5794  final private boolean jj_2_4(int xla) {
5795    jj_la = xla; jj_lastpos = jj_scanpos = token;
5796    try { return !jj_3_4(); }
5797    catch(LookaheadSuccess ls) { return true; }
5798    finally { jj_save(3, xla); }
5799  }
5800
5801  final private boolean jj_2_5(int xla) {
5802    jj_la = xla; jj_lastpos = jj_scanpos = token;
5803    try { return !jj_3_5(); }
5804    catch(LookaheadSuccess ls) { return true; }
5805    finally { jj_save(4, xla); }
5806  }
5807
5808  final private boolean jj_2_6(int xla) {
5809    jj_la = xla; jj_lastpos = jj_scanpos = token;
5810    try { return !jj_3_6(); }
5811    catch(LookaheadSuccess ls) { return true; }
5812    finally { jj_save(5, xla); }
5813  }
5814
5815  final private boolean jj_2_7(int xla) {
5816    jj_la = xla; jj_lastpos = jj_scanpos = token;
5817    try { return !jj_3_7(); }
5818    catch(LookaheadSuccess ls) { return true; }
5819    finally { jj_save(6, xla); }
5820  }
5821
5822  final private boolean jj_2_8(int xla) {
5823    jj_la = xla; jj_lastpos = jj_scanpos = token;
5824    try { return !jj_3_8(); }
5825    catch(LookaheadSuccess ls) { return true; }
5826    finally { jj_save(7, xla); }
5827  }
5828
5829  final private boolean jj_2_9(int xla) {
5830    jj_la = xla; jj_lastpos = jj_scanpos = token;
5831    try { return !jj_3_9(); }
5832    catch(LookaheadSuccess ls) { return true; }
5833    finally { jj_save(8, xla); }
5834  }
5835
5836  final private boolean jj_2_10(int xla) {
5837    jj_la = xla; jj_lastpos = jj_scanpos = token;
5838    try { return !jj_3_10(); }
5839    catch(LookaheadSuccess ls) { return true; }
5840    finally { jj_save(9, xla); }
5841  }
5842
5843  final private boolean jj_2_11(int xla) {
5844    jj_la = xla; jj_lastpos = jj_scanpos = token;
5845    try { return !jj_3_11(); }
5846    catch(LookaheadSuccess ls) { return true; }
5847    finally { jj_save(10, xla); }
5848  }
5849
5850  final private boolean jj_2_12(int xla) {
5851    jj_la = xla; jj_lastpos = jj_scanpos = token;
5852    try { return !jj_3_12(); }
5853    catch(LookaheadSuccess ls) { return true; }
5854    finally { jj_save(11, xla); }
5855  }
5856
5857  final private boolean jj_2_13(int xla) {
5858    jj_la = xla; jj_lastpos = jj_scanpos = token;
5859    try { return !jj_3_13(); }
5860    catch(LookaheadSuccess ls) { return true; }
5861    finally { jj_save(12, xla); }
5862  }
5863
5864  final private boolean jj_2_14(int xla) {
5865    jj_la = xla; jj_lastpos = jj_scanpos = token;
5866    try { return !jj_3_14(); }
5867    catch(LookaheadSuccess ls) { return true; }
5868    finally { jj_save(13, xla); }
5869  }
5870
5871  final private boolean jj_2_15(int xla) {
5872    jj_la = xla; jj_lastpos = jj_scanpos = token;
5873    try { return !jj_3_15(); }
5874    catch(LookaheadSuccess ls) { return true; }
5875    finally { jj_save(14, xla); }
5876  }
5877
5878  final private boolean jj_2_16(int xla) {
5879    jj_la = xla; jj_lastpos = jj_scanpos = token;
5880    try { return !jj_3_16(); }
5881    catch(LookaheadSuccess ls) { return true; }
5882    finally { jj_save(15, xla); }
5883  }
5884
5885  final private boolean jj_2_17(int xla) {
5886    jj_la = xla; jj_lastpos = jj_scanpos = token;
5887    try { return !jj_3_17(); }
5888    catch(LookaheadSuccess ls) { return true; }
5889    finally { jj_save(16, xla); }
5890  }
5891
5892  final private boolean jj_2_18(int xla) {
5893    jj_la = xla; jj_lastpos = jj_scanpos = token;
5894    try { return !jj_3_18(); }
5895    catch(LookaheadSuccess ls) { return true; }
5896    finally { jj_save(17, xla); }
5897  }
5898
5899  final private boolean jj_2_19(int xla) {
5900    jj_la = xla; jj_lastpos = jj_scanpos = token;
5901    try { return !jj_3_19(); }
5902    catch(LookaheadSuccess ls) { return true; }
5903    finally { jj_save(18, xla); }
5904  }
5905
5906  final private boolean jj_2_20(int xla) {
5907    jj_la = xla; jj_lastpos = jj_scanpos = token;
5908    try { return !jj_3_20(); }
5909    catch(LookaheadSuccess ls) { return true; }
5910    finally { jj_save(19, xla); }
5911  }
5912
5913  final private boolean jj_2_21(int xla) {
5914    jj_la = xla; jj_lastpos = jj_scanpos = token;
5915    try { return !jj_3_21(); }
5916    catch(LookaheadSuccess ls) { return true; }
5917    finally { jj_save(20, xla); }
5918  }
5919
5920  final private boolean jj_2_22(int xla) {
5921    jj_la = xla; jj_lastpos = jj_scanpos = token;
5922    try { return !jj_3_22(); }
5923    catch(LookaheadSuccess ls) { return true; }
5924    finally { jj_save(21, xla); }
5925  }
5926
5927  final private boolean jj_2_23(int xla) {
5928    jj_la = xla; jj_lastpos = jj_scanpos = token;
5929    try { return !jj_3_23(); }
5930    catch(LookaheadSuccess ls) { return true; }
5931    finally { jj_save(22, xla); }
5932  }
5933
5934  final private boolean jj_2_24(int xla) {
5935    jj_la = xla; jj_lastpos = jj_scanpos = token;
5936    try { return !jj_3_24(); }
5937    catch(LookaheadSuccess ls) { return true; }
5938    finally { jj_save(23, xla); }
5939  }
5940
5941  final private boolean jj_2_25(int xla) {
5942    jj_la = xla; jj_lastpos = jj_scanpos = token;
5943    try { return !jj_3_25(); }
5944    catch(LookaheadSuccess ls) { return true; }
5945    finally { jj_save(24, xla); }
5946  }
5947
5948  final private boolean jj_2_26(int xla) {
5949    jj_la = xla; jj_lastpos = jj_scanpos = token;
5950    try { return !jj_3_26(); }
5951    catch(LookaheadSuccess ls) { return true; }
5952    finally { jj_save(25, xla); }
5953  }
5954
5955  final private boolean jj_2_27(int xla) {
5956    jj_la = xla; jj_lastpos = jj_scanpos = token;
5957    try { return !jj_3_27(); }
5958    catch(LookaheadSuccess ls) { return true; }
5959    finally { jj_save(26, xla); }
5960  }
5961
5962  final private boolean jj_2_28(int xla) {
5963    jj_la = xla; jj_lastpos = jj_scanpos = token;
5964    try { return !jj_3_28(); }
5965    catch(LookaheadSuccess ls) { return true; }
5966    finally { jj_save(27, xla); }
5967  }
5968
5969  final private boolean jj_2_29(int xla) {
5970    jj_la = xla; jj_lastpos = jj_scanpos = token;
5971    try { return !jj_3_29(); }
5972    catch(LookaheadSuccess ls) { return true; }
5973    finally { jj_save(28, xla); }
5974  }
5975
5976  final private boolean jj_2_30(int xla) {
5977    jj_la = xla; jj_lastpos = jj_scanpos = token;
5978    try { return !jj_3_30(); }
5979    catch(LookaheadSuccess ls) { return true; }
5980    finally { jj_save(29, xla); }
5981  }
5982
5983  final private boolean jj_2_31(int xla) {
5984    jj_la = xla; jj_lastpos = jj_scanpos = token;
5985    try { return !jj_3_31(); }
5986    catch(LookaheadSuccess ls) { return true; }
5987    finally { jj_save(30, xla); }
5988  }
5989
5990  final private boolean jj_2_32(int xla) {
5991    jj_la = xla; jj_lastpos = jj_scanpos = token;
5992    try { return !jj_3_32(); }
5993    catch(LookaheadSuccess ls) { return true; }
5994    finally { jj_save(31, xla); }
5995  }
5996
5997  final private boolean jj_2_33(int xla) {
5998    jj_la = xla; jj_lastpos = jj_scanpos = token;
5999    try { return !jj_3_33(); }
6000    catch(LookaheadSuccess ls) { return true; }
6001    finally { jj_save(32, xla); }
6002  }
6003
6004  final private boolean jj_2_34(int xla) {
6005    jj_la = xla; jj_lastpos = jj_scanpos = token;
6006    try { return !jj_3_34(); }
6007    catch(LookaheadSuccess ls) { return true; }
6008    finally { jj_save(33, xla); }
6009  }
6010
6011  final private boolean jj_2_35(int xla) {
6012    jj_la = xla; jj_lastpos = jj_scanpos = token;
6013    try { return !jj_3_35(); }
6014    catch(LookaheadSuccess ls) { return true; }
6015    finally { jj_save(34, xla); }
6016  }
6017
6018  final private boolean jj_2_36(int xla) {
6019    jj_la = xla; jj_lastpos = jj_scanpos = token;
6020    try { return !jj_3_36(); }
6021    catch(LookaheadSuccess ls) { return true; }
6022    finally { jj_save(35, xla); }
6023  }
6024
6025  final private boolean jj_2_37(int xla) {
6026    jj_la = xla; jj_lastpos = jj_scanpos = token;
6027    try { return !jj_3_37(); }
6028    catch(LookaheadSuccess ls) { return true; }
6029    finally { jj_save(36, xla); }
6030  }
6031
6032  final private boolean jj_2_38(int xla) {
6033    jj_la = xla; jj_lastpos = jj_scanpos = token;
6034    try { return !jj_3_38(); }
6035    catch(LookaheadSuccess ls) { return true; }
6036    finally { jj_save(37, xla); }
6037  }
6038
6039  final private boolean jj_2_39(int xla) {
6040    jj_la = xla; jj_lastpos = jj_scanpos = token;
6041    try { return !jj_3_39(); }
6042    catch(LookaheadSuccess ls) { return true; }
6043    finally { jj_save(38, xla); }
6044  }
6045
6046  final private boolean jj_2_40(int xla) {
6047    jj_la = xla; jj_lastpos = jj_scanpos = token;
6048    try { return !jj_3_40(); }
6049    catch(LookaheadSuccess ls) { return true; }
6050    finally { jj_save(39, xla); }
6051  }
6052
6053  final private boolean jj_2_41(int xla) {
6054    jj_la = xla; jj_lastpos = jj_scanpos = token;
6055    try { return !jj_3_41(); }
6056    catch(LookaheadSuccess ls) { return true; }
6057    finally { jj_save(40, xla); }
6058  }
6059
6060  final private boolean jj_2_42(int xla) {
6061    jj_la = xla; jj_lastpos = jj_scanpos = token;
6062    try { return !jj_3_42(); }
6063    catch(LookaheadSuccess ls) { return true; }
6064    finally { jj_save(41, xla); }
6065  }
6066
6067  final private boolean jj_2_43(int xla) {
6068    jj_la = xla; jj_lastpos = jj_scanpos = token;
6069    try { return !jj_3_43(); }
6070    catch(LookaheadSuccess ls) { return true; }
6071    finally { jj_save(42, xla); }
6072  }
6073
6074  final private boolean jj_2_44(int xla) {
6075    jj_la = xla; jj_lastpos = jj_scanpos = token;
6076    try { return !jj_3_44(); }
6077    catch(LookaheadSuccess ls) { return true; }
6078    finally { jj_save(43, xla); }
6079  }
6080
6081  final private boolean jj_2_45(int xla) {
6082    jj_la = xla; jj_lastpos = jj_scanpos = token;
6083    try { return !jj_3_45(); }
6084    catch(LookaheadSuccess ls) { return true; }
6085    finally { jj_save(44, xla); }
6086  }
6087
6088  final private boolean jj_2_46(int xla) {
6089    jj_la = xla; jj_lastpos = jj_scanpos = token;
6090    try { return !jj_3_46(); }
6091    catch(LookaheadSuccess ls) { return true; }
6092    finally { jj_save(45, xla); }
6093  }
6094
6095  final private boolean jj_2_47(int xla) {
6096    jj_la = xla; jj_lastpos = jj_scanpos = token;
6097    try { return !jj_3_47(); }
6098    catch(LookaheadSuccess ls) { return true; }
6099    finally { jj_save(46, xla); }
6100  }
6101
6102  final private boolean jj_2_48(int xla) {
6103    jj_la = xla; jj_lastpos = jj_scanpos = token;
6104    try { return !jj_3_48(); }
6105    catch(LookaheadSuccess ls) { return true; }
6106    finally { jj_save(47, xla); }
6107  }
6108
6109  final private boolean jj_2_49(int xla) {
6110    jj_la = xla; jj_lastpos = jj_scanpos = token;
6111    try { return !jj_3_49(); }
6112    catch(LookaheadSuccess ls) { return true; }
6113    finally { jj_save(48, xla); }
6114  }
6115
6116  final private boolean jj_2_50(int xla) {
6117    jj_la = xla; jj_lastpos = jj_scanpos = token;
6118    try { return !jj_3_50(); }
6119    catch(LookaheadSuccess ls) { return true; }
6120    finally { jj_save(49, xla); }
6121  }
6122
6123  final private boolean jj_2_51(int xla) {
6124    jj_la = xla; jj_lastpos = jj_scanpos = token;
6125    try { return !jj_3_51(); }
6126    catch(LookaheadSuccess ls) { return true; }
6127    finally { jj_save(50, xla); }
6128  }
6129
6130  final private boolean jj_2_52(int xla) {
6131    jj_la = xla; jj_lastpos = jj_scanpos = token;
6132    try { return !jj_3_52(); }
6133    catch(LookaheadSuccess ls) { return true; }
6134    finally { jj_save(51, xla); }
6135  }
6136
6137  final private boolean jj_2_53(int xla) {
6138    jj_la = xla; jj_lastpos = jj_scanpos = token;
6139    try { return !jj_3_53(); }
6140    catch(LookaheadSuccess ls) { return true; }
6141    finally { jj_save(52, xla); }
6142  }
6143
6144  final private boolean jj_2_54(int xla) {
6145    jj_la = xla; jj_lastpos = jj_scanpos = token;
6146    try { return !jj_3_54(); }
6147    catch(LookaheadSuccess ls) { return true; }
6148    finally { jj_save(53, xla); }
6149  }
6150
6151  final private boolean jj_2_55(int xla) {
6152    jj_la = xla; jj_lastpos = jj_scanpos = token;
6153    try { return !jj_3_55(); }
6154    catch(LookaheadSuccess ls) { return true; }
6155    finally { jj_save(54, xla); }
6156  }
6157
6158  final private boolean jj_2_56(int xla) {
6159    jj_la = xla; jj_lastpos = jj_scanpos = token;
6160    try { return !jj_3_56(); }
6161    catch(LookaheadSuccess ls) { return true; }
6162    finally { jj_save(55, xla); }
6163  }
6164
6165  final private boolean jj_2_57(int xla) {
6166    jj_la = xla; jj_lastpos = jj_scanpos = token;
6167    try { return !jj_3_57(); }
6168    catch(LookaheadSuccess ls) { return true; }
6169    finally { jj_save(56, xla); }
6170  }
6171
6172  final private boolean jj_2_58(int xla) {
6173    jj_la = xla; jj_lastpos = jj_scanpos = token;
6174    try { return !jj_3_58(); }
6175    catch(LookaheadSuccess ls) { return true; }
6176    finally { jj_save(57, xla); }
6177  }
6178
6179  final private boolean jj_2_59(int xla) {
6180    jj_la = xla; jj_lastpos = jj_scanpos = token;
6181    try { return !jj_3_59(); }
6182    catch(LookaheadSuccess ls) { return true; }
6183    finally { jj_save(58, xla); }
6184  }
6185
6186  final private boolean jj_2_60(int xla) {
6187    jj_la = xla; jj_lastpos = jj_scanpos = token;
6188    try { return !jj_3_60(); }
6189    catch(LookaheadSuccess ls) { return true; }
6190    finally { jj_save(59, xla); }
6191  }
6192
6193  final private boolean jj_2_61(int xla) {
6194    jj_la = xla; jj_lastpos = jj_scanpos = token;
6195    try { return !jj_3_61(); }
6196    catch(LookaheadSuccess ls) { return true; }
6197    finally { jj_save(60, xla); }
6198  }
6199
6200  final private boolean jj_3R_131() {
6201    if (jj_scan_token(NE)) return true;
6202    Token xsp;
6203    xsp = jj_scanpos;
6204    if (jj_3R_200()) {
6205    jj_scanpos = xsp;
6206    if (jj_3R_201()) return true;
6207    }
6208    return false;
6209  }
6210
6211  final private boolean jj_3R_130() {
6212    if (jj_scan_token(EQ)) return true;
6213    Token xsp;
6214    xsp = jj_scanpos;
6215    if (jj_3R_198()) {
6216    jj_scanpos = xsp;
6217    if (jj_3R_199()) return true;
6218    }
6219    return false;
6220  }
6221
6222  final private boolean jj_3_48() {
6223    if (jj_3R_58()) return true;
6224    return false;
6225  }
6226
6227  final private boolean jj_3_47() {
6228    if (jj_3R_57()) return true;
6229    return false;
6230  }
6231
6232  final private boolean jj_3_46() {
6233    if (jj_3R_56()) return true;
6234    return false;
6235  }
6236
6237  final private boolean jj_3_45() {
6238    if (jj_3R_55()) return true;
6239    return false;
6240  }
6241
6242  final private boolean jj_3R_153() {
6243    if (jj_3R_242()) return true;
6244    return false;
6245  }
6246
6247  final private boolean jj_3R_54() {
6248    if (jj_3R_49()) return true;
6249    Token xsp;
6250    xsp = jj_scanpos;
6251    if (jj_3R_130()) {
6252    jj_scanpos = xsp;
6253    if (jj_3R_131()) {
6254    jj_scanpos = xsp;
6255    if (jj_3R_132()) {
6256    jj_scanpos = xsp;
6257    if (jj_3R_133()) {
6258    jj_scanpos = xsp;
6259    if (jj_3R_134()) {
6260    jj_scanpos = xsp;
6261    if (jj_3R_135()) return true;
6262    }
6263    }
6264    }
6265    }
6266    }
6267    return false;
6268  }
6269
6270  final private boolean jj_3_44() {
6271    if (jj_3R_54()) return true;
6272    return false;
6273  }
6274
6275  final private boolean jj_3_43() {
6276    if (jj_3R_53()) return true;
6277    return false;
6278  }
6279
6280  final private boolean jj_3R_118() {
6281    if (jj_3R_175()) return true;
6282    return false;
6283  }
6284
6285  final private boolean jj_3R_106() {
6286    if (jj_3R_58()) return true;
6287    return false;
6288  }
6289
6290  final private boolean jj_3R_105() {
6291    if (jj_3R_57()) return true;
6292    return false;
6293  }
6294
6295  final private boolean jj_3R_104() {
6296    if (jj_3R_56()) return true;
6297    return false;
6298  }
6299
6300  final private boolean jj_3R_103() {
6301    if (jj_3R_55()) return true;
6302    return false;
6303  }
6304
6305  final private boolean jj_3R_102() {
6306    if (jj_3R_54()) return true;
6307    return false;
6308  }
6309
6310  final private boolean jj_3R_41() {
6311    Token xsp;
6312    xsp = jj_scanpos;
6313    if (jj_3R_101()) {
6314    jj_scanpos = xsp;
6315    if (jj_3R_102()) {
6316    jj_scanpos = xsp;
6317    if (jj_3R_103()) {
6318    jj_scanpos = xsp;
6319    if (jj_3R_104()) {
6320    jj_scanpos = xsp;
6321    if (jj_3R_105()) {
6322    jj_scanpos = xsp;
6323    if (jj_3R_106()) return true;
6324    }
6325    }
6326    }
6327    }
6328    }
6329    return false;
6330  }
6331
6332  final private boolean jj_3R_101() {
6333    if (jj_3R_53()) return true;
6334    return false;
6335  }
6336
6337  final private boolean jj_3R_152() {
6338    if (jj_3R_241()) return true;
6339    return false;
6340  }
6341
6342  final private boolean jj_3R_242() {
6343    if (jj_scan_token(ALL)) return true;
6344    if (jj_scan_token(84)) return true;
6345    if (jj_3R_60()) return true;
6346    if (jj_scan_token(85)) return true;
6347    return false;
6348  }
6349
6350  final private boolean jj_3R_117() {
6351    if (jj_3R_62()) return true;
6352    return false;
6353  }
6354
6355  final private boolean jj_3R_241() {
6356    if (jj_scan_token(SOME)) return true;
6357    if (jj_scan_token(84)) return true;
6358    if (jj_3R_60()) return true;
6359    if (jj_scan_token(85)) return true;
6360    return false;
6361  }
6362
6363  final private boolean jj_3R_240() {
6364    if (jj_scan_token(ANY)) return true;
6365    if (jj_scan_token(84)) return true;
6366    if (jj_3R_60()) return true;
6367    if (jj_scan_token(85)) return true;
6368    return false;
6369  }
6370
6371  final private boolean jj_3R_111() {
6372    if (jj_3R_60()) return true;
6373    return false;
6374  }
6375
6376  final private boolean jj_3R_59() {
6377    Token xsp;
6378    xsp = jj_scanpos;
6379    if (jj_3R_151()) {
6380    jj_scanpos = xsp;
6381    if (jj_3R_152()) {
6382    jj_scanpos = xsp;
6383    if (jj_3R_153()) return true;
6384    }
6385    }
6386