History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/com/sun/tools/example/debug/expr/ExpressionParser.java (1 of 18352 files). Show all

Unified · Split

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