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