diff options
Diffstat (limited to 'src/main/java/io/devnulllabs/openjava/tools/parser/Parser.java')
| -rw-r--r-- | src/main/java/io/devnulllabs/openjava/tools/parser/Parser.java | 6327 |
1 files changed, 6327 insertions, 0 deletions
diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/Parser.java b/src/main/java/io/devnulllabs/openjava/tools/parser/Parser.java new file mode 100644 index 0000000..749fa53 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/Parser.java @@ -0,0 +1,6327 @@ +package io.devnulllabs.openjava.tools.parser; + + +import java.lang.reflect.Method; +import java.util.Hashtable; +import java.util.Vector; + +import io.devnulllabs.openjava.mop.ClassEnvironment; +import io.devnulllabs.openjava.mop.ClosedEnvironment; +import io.devnulllabs.openjava.mop.Environment; +import io.devnulllabs.openjava.mop.FileEnvironment; +import io.devnulllabs.openjava.mop.OJSystem; +import io.devnulllabs.openjava.ptree.AllocationExpression; +import io.devnulllabs.openjava.ptree.ArrayAccess; +import io.devnulllabs.openjava.ptree.ArrayAllocationExpression; +import io.devnulllabs.openjava.ptree.ArrayInitializer; +import io.devnulllabs.openjava.ptree.AssignmentExpression; +import io.devnulllabs.openjava.ptree.BinaryExpression; +import io.devnulllabs.openjava.ptree.Block; +import io.devnulllabs.openjava.ptree.BreakStatement; +import io.devnulllabs.openjava.ptree.CaseGroup; +import io.devnulllabs.openjava.ptree.CaseGroupList; +import io.devnulllabs.openjava.ptree.CastExpression; +import io.devnulllabs.openjava.ptree.CatchBlock; +import io.devnulllabs.openjava.ptree.CatchList; +import io.devnulllabs.openjava.ptree.ClassDeclaration; +import io.devnulllabs.openjava.ptree.ClassDeclarationList; +import io.devnulllabs.openjava.ptree.ClassLiteral; +import io.devnulllabs.openjava.ptree.CompilationUnit; +import io.devnulllabs.openjava.ptree.ConditionalExpression; +import io.devnulllabs.openjava.ptree.ConstructorDeclaration; +import io.devnulllabs.openjava.ptree.ConstructorInvocation; +import io.devnulllabs.openjava.ptree.ContinueStatement; +import io.devnulllabs.openjava.ptree.DoWhileStatement; +import io.devnulllabs.openjava.ptree.EmptyStatement; +import io.devnulllabs.openjava.ptree.Expression; +import io.devnulllabs.openjava.ptree.ExpressionList; +import io.devnulllabs.openjava.ptree.ExpressionStatement; +import io.devnulllabs.openjava.ptree.FieldAccess; +import io.devnulllabs.openjava.ptree.FieldDeclaration; +import io.devnulllabs.openjava.ptree.ForStatement; +import io.devnulllabs.openjava.ptree.IfStatement; +import io.devnulllabs.openjava.ptree.InstanceofExpression; +import io.devnulllabs.openjava.ptree.LabeledStatement; +import io.devnulllabs.openjava.ptree.Literal; +import io.devnulllabs.openjava.ptree.MemberDeclaration; +import io.devnulllabs.openjava.ptree.MemberDeclarationList; +import io.devnulllabs.openjava.ptree.MemberInitializer; +import io.devnulllabs.openjava.ptree.MethodCall; +import io.devnulllabs.openjava.ptree.MethodDeclaration; +import io.devnulllabs.openjava.ptree.ModifierList; +import io.devnulllabs.openjava.ptree.Parameter; +import io.devnulllabs.openjava.ptree.ParameterList; +import io.devnulllabs.openjava.ptree.ParseTree; +import io.devnulllabs.openjava.ptree.ReturnStatement; +import io.devnulllabs.openjava.ptree.SelfAccess; +import io.devnulllabs.openjava.ptree.Statement; +import io.devnulllabs.openjava.ptree.StatementList; +import io.devnulllabs.openjava.ptree.SwitchStatement; +import io.devnulllabs.openjava.ptree.SynchronizedStatement; +import io.devnulllabs.openjava.ptree.ThrowStatement; +import io.devnulllabs.openjava.ptree.TryStatement; +import io.devnulllabs.openjava.ptree.TypeName; +import io.devnulllabs.openjava.ptree.UnaryExpression; +import io.devnulllabs.openjava.ptree.Variable; +import io.devnulllabs.openjava.ptree.VariableDeclaration; +import io.devnulllabs.openjava.ptree.VariableDeclarator; +import io.devnulllabs.openjava.ptree.VariableInitializer; +import io.devnulllabs.openjava.ptree.WhileStatement; +import io.devnulllabs.openjava.syntax.SyntaxRule; +import io.devnulllabs.openjava.syntax.TokenSource; +import io.devnulllabs.openjava.tools.DebugOut; + + +public class Parser implements ParserConstants { + /** + * Allocates a new parser object who gets tokens from the given parser + * object. + * + * @param parser this is used to get tokens via <code>getToken()</code> + * or <code>getNextToken()</code>. + */ + public Parser( Parser parser ) { + this( (ParserTokenManager) new CustomTokenManager( parser, OJSystem.env ) ); + } + + public Parser( TokenSource token_src ) { + this( new TokenSourceAdapter( token_src ) ); + } + + private final String getComment() { + Token token = getToken( 1 ).specialToken; + return ((token == null) ? null : token.image); + } + + + private final static int makeInt( String str ) { + if (str.length() == 1) { + return Integer.valueOf( str ).intValue(); + } else if (str.startsWith( "0x" ) || str.startsWith( "0X" )) { + return Integer.valueOf( str.substring( 2 ), 16 ).intValue(); + } else if (str.startsWith( "0" )) { + return Integer.valueOf( str.substring( 1 ), 8 ).intValue(); + } + return Integer.valueOf( str ).intValue(); + } + private final static long makeLong( String str ) { + if (str.length() == 1) { + return Long.valueOf( str ).longValue(); + } else if (str.startsWith( "0x" ) || str.startsWith( "0X" )) { + str = str.substring( 2 ); + if (str.endsWith( "l" ) || str.endsWith( "L" )) { + str = str.substring( 0, str.length() - 1 ); + } + return Long.valueOf( str, 16 ).longValue(); + } else if (str.startsWith( "0" )) { + str = str.substring( 1 ); + if (str.endsWith( "l" ) || str.endsWith( "L" )) { + str = str.substring( 0, str.length() - 1 ); + } + return Long.valueOf( str, 8 ).longValue(); + } + return Long.valueOf( str ).longValue(); + } + + /** + * Detects class or interface name and metaclass + */ + private final ClassEnvironment setClassEnvironment( Environment base_env ) + throws ParseException + { + int ptr = 1; + for (; roughModifierCheck( getToken( ptr ) ) ; ++ptr) ; + Token c_or_i = getToken( ptr++ ); + if (c_or_i.kind != CLASS && c_or_i.kind != INTERFACE) { + throw new ParseException( "'class' or 'interface' expected : " + + c_or_i.image ); + } + Token cname = getToken( ptr++ ); + if (cname.kind != IDENTIFIER) { + throw new ParseException( "class name expected : " + + c_or_i.image ); + } + String classname = cname.image; + + ClassEnvironment result = new ClassEnvironment(base_env, classname); + + Token inst = getToken(ptr++); + if (inst.kind != INSTANTIATES) { + ptr++; + } else { + IntAndObj tmp = consumeMetaclassName(ptr); ptr = tmp.ptr; + String meta = base_env.toQualifiedName((String) tmp.obj); + OJSystem.metabind(result.toQualifiedName(classname), meta); + } + + return result; + } + + private IntAndObj consumeMetaclassName( int ptr ) throws ParseException { + Token token = getToken( ptr++ ); + if (token.kind != IDENTIFIER) { + throw new ParseException( "metaclass name exptected : " + + token.image ); + } + StringBuffer buf = new StringBuffer( token.image ); + while (getToken( ptr ).kind == DOT + && getToken( ptr + 1 ).kind == IDENTIFIER) { + buf.append( "." ).append( getToken( ptr + 1 ).image ); + ptr += 2; + } + return new IntAndObj( ptr, buf.toString() ); + } + + /** + * This is used to check io.devnulllabs.openjava user modifier semantically. + */ + private final boolean OpenJavaModifierLookahead( Environment env ) { + return modifierCheck( env, getToken( 1 ) ); + } + + /** + * This is used to check OpenJava user modifier semantically. + */ + private final boolean ModifierLookahead( Environment env ) { + return modifierCheck( env, getToken( 1 ) ); + } + + boolean DeclSuffixLookahead( Environment env ) { + String typename = env.currentClassName(); + String keyword = consumeKeyword( 1 ); + if (keyword == null) return false; + Class meta = toExecutable( env, typename ); + return invokeOJClass_isRegisteredKeyword( meta, keyword ); + } + + boolean TypeSuffixLookahead( Environment env, String typename ) { + String keyword = consumeKeyword( 1 ); + if (keyword == null) return false; + Class meta = toExecutable( env, typename ); + return invokeOJClass_isRegisteredKeyword( meta, keyword ); + } + + private static final boolean modifierCheck( Environment env, Token t ) { + if (pureModifierCheck( t )) return true; + if (t.kind != IDENTIFIER) return false; + Class meta = toExecutable( env, env.currentClassName() ); + if (meta == null) return false; + return invokeOJClass_isRegisteredModifier( meta, t.image ); + } + + private String consumeKeyword( int ptr ) { + Token token = getToken( ptr ); + if (token.kind != IDENTIFIER) return null; + return token.image; + } + + static final Class toExecutable( Environment env, String typename ) { + String qname = env.toQualifiedName( typename ); + return OJSystem.getMetabind( qname ); + } + + static boolean invokeOJClass_isRegisteredKeyword( Class meta, + String keyword ) + { + try { + Method m = meta.getMethod( "isRegisteredKeyword", + new Class[]{ String . class} ); + Boolean b = (Boolean) m.invoke( null, new Object[]{ keyword } ); + return b.booleanValue(); + } catch ( Exception e ) {} + return false; + } + + static SyntaxRule invokeOJClass_getDeclSuffixRule(Environment env, + Class meta, + String keyword) + { + SyntaxRule result = null; + try { + Method m = meta.getMethod("getDeclSuffixRule", + new Class[]{ Environment.class, + String.class }); + result = (SyntaxRule) m.invoke(null, new Object[]{ env, keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + if (result != null) return result; + try { + Method m = meta.getMethod("getDeclSuffixRule", + new Class[]{ String.class }); + result = (SyntaxRule) m.invoke(null, new Object[]{ keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + return result; + } + + static SyntaxRule invokeOJClass_getTypeSuffixRule(Environment env, + Class meta, + String keyword) + { + SyntaxRule result = null; + try { + Method m = meta.getMethod("getTypeSuffixRule", + new Class[]{ Environment.class, + String.class }); + result = (SyntaxRule) m.invoke(null, new Object[]{ env, keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + if (result != null) return result; + try { + Method m = meta.getMethod("getTypeSuffixRule", + new Class[]{ String.class}); + result = (SyntaxRule) m.invoke(null, new Object[]{ keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + return result; + } + + static boolean invokeOJClass_isRegisteredModifier( Class meta, + String keyword ) + { + try { + Method m = meta.getMethod( "isRegisteredModifier", + new Class[]{ String . class} ); + Boolean b = (Boolean) m.invoke( null, new Object[]{ keyword } ); + return b.booleanValue(); + } catch ( Exception e ) {} + return false; + } + + /** + * This is used to check constructors semantically. + */ + private final boolean ConstructorDeclarationLookahead( + ClassEnvironment env ) { + int ptr; + for (ptr = 1; modifierCheck( env, getToken( ptr ) ) ; ++ptr) ; + String simplename = Environment.toSimpleName( env.currentClassName() ); + //if (! getToken( ptr ).image.equals( simplename ) + // || getToken( ptr + 1 ).kind != LPAREN) { + // return false; + //} + //return true; + return (getToken(ptr + 1).kind == LPAREN); + } + + /** + * This will used to check local variable declaration semantically. + */ + private final boolean LocalVariableDeclarationLookahead( + Environment env ) { + int ptr; + for (ptr = 1; modifierCheck( env, getToken( ptr ) ) ; ++ptr) ; + int old_ptr = ptr; + ptr = consumePureResultType( old_ptr ); + if (ptr != old_ptr && getToken( ptr ).kind == IDENTIFIER) { + return true; + } + return false; + } + + private final boolean roughModifierCheck( Token t ) { + if (pureModifierCheck( t )) return true; + return (t.kind == IDENTIFIER); + } + + private static final boolean pureModifierCheck( Token t ) { + switch (t.kind) { + case ABSTRACT : case FINAL : case PUBLIC : case PRIVATE : + case PROTECTED : case STATIC : case TRANSIENT : case VOLATILE : + case NATIVE : case SYNCHRONIZED : + return true; + } + return false; + } + + private final boolean ConstructorInvocationLookahead() { + int ptr = 1; + while (getToken(ptr).kind != EOF) { + if (getToken(ptr).kind == SUPER + && getToken(ptr + 1).kind == LPAREN) { + return true; + } + if (getToken(ptr).kind == SEMICOLON) return false; + if (getToken(ptr).kind == RBRACE) return false; + ++ptr; + } + return false; + } + + private final boolean AssignmentLookahead() { + int ptr = 1; + switch (getToken( ptr ).kind) { + case LPAREN : + ptr = consumeParenPair( ptr ); + break; + case IDENTIFIER : + case THIS : + case SUPER : + ptr++; + break; + default : + return false; + } + for (boolean cont = true; cont;) { + switch (getToken( ptr ).kind) { + case LPAREN : + ptr = consumeParenPair( ptr ); + break; + case LBRACKET : + ptr = consumeBracketPair( ptr ); + break; + case DOT : + ptr++; + if (getToken( ptr ).kind != IDENTIFIER) return false; + ptr++; + break; + default : + cont = false; + } + } + return assignmentOperatorCheck( getToken( ptr ) ); + } + + private final int consumeParenPair( int ptr ) { + int nest = 1; + for (++ptr; nest > 0; ptr++) { + if (getToken( ptr ).kind == LPAREN) nest++; + if (getToken( ptr ).kind == RPAREN) nest--; + } + return ptr; + } + + private final int consumeBracketPair( int ptr ) { + int nest = 1; + for (++ptr; nest > 0; ptr++) { + if (getToken( ptr ).kind == LBRACKET) nest++; + if (getToken( ptr ).kind == RBRACKET) nest--; + } + return ptr; + } + + private static final boolean assignmentOperatorCheck( Token t ) { + if (t.kind == ASSIGN) return true; + if (t.kind == PLUSASSIGN) return true; + if (t.kind == MINUSASSIGN) return true; + if (t.kind == STARASSIGN) return true; + if (t.kind == SLASHASSIGN) return true; + if (t.kind == ANDASSIGN) return true; + if (t.kind == ORASSIGN) return true; + if (t.kind == XORASSIGN) return true; + if (t.kind == REMASSIGN) return true; + if (t.kind == LSHIFTASSIGN) return true; + if (t.kind == RSIGNEDSHIFTASSIGN) return true; + if (t.kind == RUNSIGNEDSHIFTASSIGN) return true; + return false; + } + + private final boolean ClassLiteralLookahead() { + int ptr = 1; + ptr = consumePureResultType( ptr ); + if (ptr == 1) return false; + /** here should be user suffix check **/ + if (getToken( ptr ).kind != DOT) return false; + if (getToken( ptr + 1 ).kind != CLASS) return false; + return true; + } + + private final int consumePureResultType( int ptr ) { + Token token = getToken( ptr ); + if (primitiveTypeCheck( token )) { + ptr++; + } else if (token.kind == IDENTIFIER) { + ptr++; + while (getToken( ptr ).kind == DOT + && getToken( ptr + 1 ).kind == IDENTIFIER) { + ptr += 2; + } + } else { + return ptr; + } + + while (getToken( ptr ).kind == LBRACKET + && getToken( ptr + 1 ).kind == RBRACKET) { + ptr += 2; + } + + return ptr; + } + + private final boolean primitiveTypeCheck( Token t ) { + if (t.kind == BOOLEAN || t.kind == CHAR || t.kind == BYTE + || t.kind == SHORT || t.kind == INT || t.kind == LONG + || t.kind == FLOAT || t.kind == DOUBLE || t.kind == VOID) { + return true; + } + return false; + } + + void debug_message1() throws ParseException { + DebugOut.println( "debug1 : " + getToken( 0 ).image + + " , " + getToken( 1 ).image ); + } + + ParseTree UserDeclSuffix(Environment env, String keyword) throws ParseException { + String typename = env.currentClassName(); + Class meta = toExecutable(env, typename); + SyntaxRule rule = invokeOJClass_getDeclSuffixRule(env, meta, keyword); + CustomTokenManager token_mgr = new CustomTokenManager(this, env); + token_mgr.assume(); + ParseTree result = rule.consume(token_mgr); + token_mgr.fix(); + return result; + } + + ParseTree UserTypeSuffix(Environment env, String typename, String keyword) throws ParseException { + Class meta = toExecutable(env, typename); + SyntaxRule rule = invokeOJClass_getTypeSuffixRule(env, meta, keyword); + CustomTokenManager token_mgr = new CustomTokenManager(this, env); + token_mgr.assume(); + ParseTree result = rule.consume(token_mgr); + token_mgr.fix(); + return result; + } + + void E() throws ParseException { + } + +/***************************************** + * Syntactical Descriptions * + *****************************************/ + +/* + * Program structuring syntax follows. + */ + final public CompilationUnit CompilationUnit(Environment base_env) throws ParseException { + CompilationUnit result; + FileEnvironment env = new FileEnvironment( base_env ); + String p1; + String[] p2; + ClassDeclarationList p3; + /**/DebugOut.println( "#CompilationUnit()" ); + String comment = getComment(); + p1 = PackageDeclarationOpt(); + p2 = ImportDeclarationListOpt(); + env.setPackage( p1 ); + for (int i = 0; i < p2.length; ++i) { + if (CompilationUnit.isOnDemandImport( p2[i] )) { + String pack_cls = CompilationUnit.trimOnDemand( p2[i] ); + env.importPackage( pack_cls ); + } else { + env.importClass( p2[i] ); + } + } + label_1: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SEMICOLON: + ; + break; + default: + jj_la1[0] = jj_gen; + break label_1; + } + jj_consume_token(SEMICOLON); + } + p3 = TypeDeclarationListOpt(env); + jj_consume_token(0); + result = new CompilationUnit( p1, p2, p3 ); + result.setComment( comment ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public String PackageDeclarationOpt() throws ParseException { + String p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PACKAGE: + jj_consume_token(PACKAGE); + p1 = Name(); + jj_consume_token(SEMICOLON); + {if (true) return p1;} + break; + default: + jj_la1[1] = jj_gen; + E(); + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public String[] ImportDeclarationListOpt() throws ParseException { + String[] result; + String p1; + Vector v = new Vector(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IMPORT: + label_2: + while (true) { + p1 = ImportDeclaration(); + v.addElement( p1 ); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IMPORT: + ; + break; + default: + jj_la1[2] = jj_gen; + break label_2; + } + } + result = new String[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (String) v.elementAt( i ); + } + {if (true) return result;} + break; + default: + jj_la1[3] = jj_gen; + E(); + {if (true) return new String[0];} + } + throw new Error("Missing return statement in function"); + } + + final public String ImportDeclaration() throws ParseException { + String p1; + StringBuffer strbuf = new StringBuffer(); + jj_consume_token(IMPORT); + Identifier(); + strbuf.append( getToken( 0 ).image ); + label_3: + while (true) { + if (jj_2_1(2)) { + ; + } else { + break label_3; + } + jj_consume_token(DOT); + Identifier(); + strbuf.append( "." + getToken( 0 ).image ); + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case DOT: + jj_consume_token(DOT); + jj_consume_token(STAR); + strbuf.append( ".*" ); + break; + default: + jj_la1[4] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); + {if (true) return strbuf.toString();} + throw new Error("Missing return statement in function"); + } + + final public ClassDeclarationList TypeDeclarationListOpt(Environment env) throws ParseException { + ClassEnvironment newenv; + ClassDeclarationList result = new ClassDeclarationList(); + ClassDeclaration p1; + if ((getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF)) { + label_4: + while (true) { + newenv = setClassEnvironment( env ); + p1 = TypeDeclaration(newenv); + label_5: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SEMICOLON: + ; + break; + default: + jj_la1[5] = jj_gen; + break label_5; + } + jj_consume_token(SEMICOLON); + } + result.add( p1 ); + if ((getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF)) { + ; + } else { + break label_4; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration TypeDeclaration(ClassEnvironment env) throws ParseException { + ClassDeclaration result; + ClassDeclaration p1; + Token ctoken = getToken( 1 ).specialToken; + String comment = getComment(); + if (jj_2_2(2147483647)) { + p1 = ClassDeclaration(env); + } else { + p1 = InterfaceDeclaration(env); + } + result = p1; + result.setComment( comment ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public String Identifier() throws ParseException { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + jj_consume_token(IDENTIFIER); + {if (true) return getToken( 0 ).image;} + break; + case METACLASS: + jj_consume_token(METACLASS); + {if (true) return "metaclass";} + break; + default: + jj_la1[6] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public String[] MetaclassesOpt(Environment env) throws ParseException { + String[] result; + String p1; + String p2; + Vector v = new Vector(); + String qname; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + jj_consume_token(METACLASS); + p1 = Name(); + qname = env.toQualifiedName( p1 ); + v.addElement( qname ); + /****/DebugOut.print( "metaclass " + qname ); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + jj_consume_token(COMMA); + p2 = Name(); + qname = env.toQualifiedName( p2 ); + /****/DebugOut.print( ", " + qname ); + break; + default: + jj_la1[7] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COLON: + jj_consume_token(COLON); + break; + case SEMICOLON: + jj_consume_token(SEMICOLON); + break; + default: + jj_la1[8] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + /****/DebugOut.println( " :" ); + result = new String[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (String) v.elementAt( i ); + } + {if (true) return result;} + break; + default: + jj_la1[9] = jj_gen; + E(); + {if (true) return new String[0];} + } + throw new Error("Missing return statement in function"); + } + + final public String InstantiatesPhraseOpt(ClassEnvironment env) throws ParseException { + String p1 = null; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INSTANTIATES: + jj_consume_token(INSTANTIATES); + p1 = Name(); + {if (true) return p1;} + break; + default: + jj_la1[10] = jj_gen; + E(); + {if (true) return p1;} + } + throw new Error("Missing return statement in function"); + } + + final public String OpenJavaModifier() throws ParseException { + String result; + jj_consume_token(IDENTIFIER); + result = getToken( 0 ).image; + DebugOut.println( "user modifier detected : " + result ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Hashtable OpenJavaDeclSuffixListOpt(Environment env) throws ParseException { + Hashtable result = new Hashtable(); + String p1; + ParseTree p2; + if (DeclSuffixLookahead( env )) { + label_6: + while (true) { + p1 = Identifier(); + p2 = UserDeclSuffix(env, p1); + DebugOut.println( "decl suffix : " + p1 + " " + p2 ); + result.put( p1, p2 ); + if (DeclSuffixLookahead( env )) { + ; + } else { + break label_6; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public Hashtable OpenJavaTypeSuffixListOpt(Environment env, String typename) throws ParseException { + Hashtable result = new Hashtable(); + String p1; + ParseTree p2; + if (TypeSuffixLookahead( env, typename )) { + label_7: + while (true) { + p1 = Identifier(); + p2 = UserTypeSuffix(env, typename, p1); + DebugOut.println( "type suffix : " + p1 + " " + p2 ); + result.put( p1, p2 ); + if (TypeSuffixLookahead( env, typename )) { + ; + } else { + break label_7; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public int Modifier() throws ParseException { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ABSTRACT: + jj_consume_token(ABSTRACT); + {if (true) return ModifierList.ABSTRACT;} + break; + case FINAL: + jj_consume_token(FINAL); + {if (true) return ModifierList.FINAL;} + break; + case PUBLIC: + jj_consume_token(PUBLIC); + {if (true) return ModifierList.PUBLIC;} + break; + case PRIVATE: + jj_consume_token(PRIVATE); + {if (true) return ModifierList.PRIVATE;} + break; + case PROTECTED: + jj_consume_token(PROTECTED); + {if (true) return ModifierList.PROTECTED;} + break; + case STATIC: + jj_consume_token(STATIC); + {if (true) return ModifierList.STATIC;} + break; + case TRANSIENT: + jj_consume_token(TRANSIENT); + {if (true) return ModifierList.TRANSIENT;} + break; + case VOLATILE: + jj_consume_token(VOLATILE); + {if (true) return ModifierList.VOLATILE;} + break; + case NATIVE: + jj_consume_token(NATIVE); + {if (true) return ModifierList.NATIVE;} + break; + case SYNCHRONIZED: + jj_consume_token(SYNCHRONIZED); + {if (true) return ModifierList.SYNCHRONIZED;} + break; + default: + jj_la1[11] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/* + * Declaration syntax follows. + */ + final public ClassDeclaration ClassDeclaration(ClassEnvironment env) throws ParseException { + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#ClassDeclaration()" ); + p1 = ClassModifiersOpt(env); + p2 = UnmodifiedClassDeclaration(env); + p2.setModifiers( p1 ); + {if (true) return p2;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList ClassModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if ((getToken( 1 ).kind != CLASS)) { + label_8: + while (true) { + if (jj_2_3(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_8; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration UnmodifiedClassDeclaration(ClassEnvironment env) throws ParseException { + ClassDeclaration result; + String p1; + TypeName[] p2; + TypeName[] p3; + MemberDeclarationList p4; + String mm; + Hashtable sf; + jj_consume_token(CLASS); + p1 = Identifier(); + mm = InstantiatesPhraseOpt(env); + p2 = ExtendsPhraseOpt(env); + p3 = ImplementsPhraseOpt(env); + sf = OpenJavaDeclSuffixListOpt(env); + p4 = ClassBody(env); + result = new ClassDeclaration( null, p1, p2, p3, p4 ); + result.setSuffixes( sf ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public TypeName[] ExtendsPhraseOpt(Environment env) throws ParseException { + TypeName[] p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EXTENDS: + jj_consume_token(EXTENDS); + p1 = TypeNameList(env); + {if (true) return p1;} + break; + default: + jj_la1[12] = jj_gen; + E(); + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public TypeName[] ImplementsPhraseOpt(Environment env) throws ParseException { + TypeName[] p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IMPLEMENTS: + jj_consume_token(IMPLEMENTS); + p1 = TypeNameList(env); + {if (true) return p1;} + break; + default: + jj_la1[13] = jj_gen; + E(); + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList ClassBody(ClassEnvironment env) throws ParseException { + MemberDeclarationList p1; + + DebugOut.println( "#ClassBody()" ); + jj_consume_token(LBRACE); + label_9: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SEMICOLON: + ; + break; + default: + jj_la1[14] = jj_gen; + break label_9; + } + jj_consume_token(SEMICOLON); + } + p1 = ClassBodyDeclarationListOpt(env); + jj_consume_token(RBRACE); + {if (true) return p1;} + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList ClassBodyDeclarationListOpt(ClassEnvironment env) throws ParseException { + MemberDeclarationList result = new MemberDeclarationList(); + MemberDeclarationList p1; + if ((getToken( 1 ).kind != RBRACE)) { + label_10: + while (true) { + p1 = ClassBodyDeclaration(env); + label_11: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SEMICOLON: + ; + break; + default: + jj_la1[15] = jj_gen; + break label_11; + } + jj_consume_token(SEMICOLON); + } + result.addAll( p1 ); + if ((getToken( 1 ).kind != RBRACE)) { + ; + } else { + break label_10; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration NestedTypeDeclaration(ClassEnvironment env) throws ParseException { + ClassDeclaration result; + ClassDeclaration p1; + Token ctoken = getToken( 1 ).specialToken; + String comment = getComment(); + if (jj_2_4(2147483647)) { + p1 = NestedClassDeclaration(env); + } else { + p1 = NestedInterfaceDeclaration(env); + } + result = p1; + result.setComment( comment ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration NestedClassDeclaration(ClassEnvironment env) throws ParseException { + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#NestedClassDeclaration()" ); + p1 = NestedClassModifiersOpt(env); + p2 = UnmodifiedClassDeclaration(env); + p2.setModifiers( p1 ); + {if (true) return p2;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList NestedClassModifiersOpt(ClassEnvironment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if ((getToken( 1 ).kind != CLASS)) { + label_12: + while (true) { + if (jj_2_5(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_12; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList ClassBodyDeclaration(ClassEnvironment env) throws ParseException { + ClassEnvironment newenv; + MemberDeclarationList result; + MemberDeclaration p1; + MemberDeclarationList p2; + if (jj_2_6(2147483647)) { + p1 = MemberInitializer(env); + result = new MemberDeclarationList( p1 ); + {if (true) return result;} + } else if (jj_2_7(2147483647)) { + newenv = setClassEnvironment( env ); + p1 = NestedTypeDeclaration(newenv); + result = new MemberDeclarationList( p1 ); + {if (true) return result;} + } else if (ConstructorDeclarationLookahead( env )) { + p1 = ConstructorDeclaration(env); + result = new MemberDeclarationList( p1 ); + {if (true) return result;} + } else { + p2 = MethodOrFieldDeclaration(env); + {if (true) return p2;} + } + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList MethodOrFieldDeclaration(Environment base_env) throws ParseException { + Environment env = new ClosedEnvironment( base_env ); + MemberDeclarationList result = new MemberDeclarationList(); + ModifierList p1; + TypeName p2; + String p3; + ParameterList p4; + int p5; + TypeName[] p6; + StatementList p7; + VariableDeclarator p8; + Hashtable sf; + Token ctoken = getToken( 1 ).specialToken; + String comment = getComment(); + p1 = MemberModifiersOpt(base_env); + p2 = Type(base_env); + if (jj_2_8(2147483647)) { + p3 = Identifier(); + p4 = FormalParameters(env); + p5 = EmptyBracketsOpt(); + p6 = ThrowsPhraseOpt(base_env); + sf = OpenJavaDeclSuffixListOpt(env); + p7 = MethodBody(env); + p2.addDimension( p5 ); + MethodDeclaration mthd + = new MethodDeclaration( p1, p2, p3, p4, p6, p7 ); + mthd.setSuffixes( sf ); + mthd.setComment( comment ); + result.add( mthd ); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p8 = VariableDeclarator(base_env); + FieldDeclaration fld1 = new FieldDeclaration( p1, p2, p8 ); + fld1.setComment( comment ); + result.add( fld1 ); + label_13: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[16] = jj_gen; + break label_13; + } + jj_consume_token(COMMA); + p8 = VariableDeclarator(env); + FieldDeclaration fld2 = new FieldDeclaration( p1, p2, p8 ); + fld2.setComment( comment ); + result.add( fld2 ); + } + jj_consume_token(SEMICOLON); + break; + default: + jj_la1[17] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public TypeName[] ThrowsPhraseOpt(Environment env) throws ParseException { + TypeName[] p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case THROWS: + jj_consume_token(THROWS); + p1 = TypeNameList(env); + {if (true) return p1;} + break; + default: + jj_la1[18] = jj_gen; + E(); + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public StatementList MethodBody(Environment env) throws ParseException { + StatementList p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p1 = BlockedBody(env); + {if (true) return p1;} + break; + case SEMICOLON: + jj_consume_token(SEMICOLON); + {if (true) return null;} + break; + default: + jj_la1[19] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public ModifierList MemberModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if (modifierCheck( env, getToken( 1 ) )) { + label_14: + while (true) { + if (jj_2_9(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_14; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration InterfaceDeclaration(ClassEnvironment env) throws ParseException { + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#InterfaceDeclaration()" ); + p1 = InterfaceModifiersOpt(env); + p2 = UnmodifiedInterfaceDeclaration(env); + p2.setModifiers( p1 ); + {if (true) return p2;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList InterfaceModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if ((getToken( 1 ).kind != INTERFACE)) { + label_15: + while (true) { + if (jj_2_10(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_15; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration NestedInterfaceDeclaration(ClassEnvironment env) throws ParseException { + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#NestedInterfaceDeclaration()" ); + p1 = NestedInterfaceModifiersOpt(env); + p2 = UnmodifiedInterfaceDeclaration(env); + p2.setModifiers( p1 ); + {if (true) return p2;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList NestedInterfaceModifiersOpt(ClassEnvironment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if ((getToken( 1 ).kind != INTERFACE)) { + label_16: + while (true) { + if (jj_2_11(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_16; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration UnmodifiedInterfaceDeclaration(ClassEnvironment env) throws ParseException { + ClassDeclaration result; + String p1; + TypeName[] p2; + MemberDeclarationList p3; + String mm; + Hashtable sf; + jj_consume_token(INTERFACE); + p1 = Identifier(); + mm = InstantiatesPhraseOpt(env); + p2 = ExtendsPhraseOpt(env); + sf = OpenJavaDeclSuffixListOpt(env); + p3 = InterfaceBody(env); + result = new ClassDeclaration( null, p1, p2, null, p3, false ); + result.setSuffixes( sf ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList InterfaceBody(ClassEnvironment env) throws ParseException { + MemberDeclarationList p1; + jj_consume_token(LBRACE); + p1 = InterfaceBodyDeclarationListOpt(env); + jj_consume_token(RBRACE); + {if (true) return p1;} + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList InterfaceBodyDeclarationListOpt(ClassEnvironment env) throws ParseException { + MemberDeclarationList result = new MemberDeclarationList(); + MemberDeclarationList p1; + if ((getToken( 1 ).kind != RBRACE)) { + label_17: + while (true) { + p1 = InterfaceBodyDeclaration(env); + result.addAll( p1 ); + if ((getToken( 1 ).kind != RBRACE)) { + ; + } else { + break label_17; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList InterfaceBodyDeclaration(ClassEnvironment env) throws ParseException { + ClassEnvironment newenv; + MemberDeclarationList result; + ClassDeclaration p1; + MemberDeclarationList p2; + if (jj_2_12(2147483647)) { + newenv = setClassEnvironment( env ); + p1 = NestedTypeDeclaration(newenv); + result = new MemberDeclarationList( p1 ); + {if (true) return result;} + } else { + p2 = MethodOrFieldDeclaration(env); + {if (true) return p2;} + } + throw new Error("Missing return statement in function"); + } + + final public VariableDeclarator VariableDeclarator(Environment env) throws ParseException { + String p1; + int p2; + VariableInitializer p3 = null; + p1 = Identifier(); + p2 = EmptyBracketsOpt(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ASSIGN: + jj_consume_token(ASSIGN); + p3 = VariableInitializer(env); + break; + default: + jj_la1[20] = jj_gen; + ; + } + {if (true) return new VariableDeclarator( p1, p2, p3 );} + throw new Error("Missing return statement in function"); + } + + final public int EmptyBracketsOpt() throws ParseException { + int result = 0; + if (jj_2_14(2147483647)) { + label_18: + while (true) { + jj_consume_token(LBRACKET); + jj_consume_token(RBRACKET); + result++; + if (jj_2_13(2)) { + ; + } else { + break label_18; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public VariableInitializer VariableInitializer(Environment env) throws ParseException { + VariableInitializer p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p1 = ArrayInitializer(env); + {if (true) return p1;} + break; + default: + jj_la1[21] = jj_gen; + if (jj_2_15(1)) { + p1 = Expression(env); + {if (true) return p1;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + + final public ArrayInitializer ArrayInitializer(Environment env) throws ParseException { + ArrayInitializer result = new ArrayInitializer(); + VariableInitializer p1; + jj_consume_token(LBRACE); + if ((getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != COMMA)) { + p1 = VariableInitializer(env); + result.add( p1 ); + label_19: + while (true) { + if ((getToken( 1 ).kind == COMMA + && getToken( 2 ).kind != RBRACE)) { + ; + } else { + break label_19; + } + jj_consume_token(COMMA); + p1 = VariableInitializer(env); + result.add( p1 ); + } + } else { + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + jj_consume_token(COMMA); + result.omitRemainder( true ); + break; + default: + jj_la1[22] = jj_gen; + ; + } + jj_consume_token(RBRACE); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ParameterList FormalParameters(Environment env) throws ParseException { + ParameterList result = new ParameterList(); + Parameter p1; + + DebugOut.println( "#FormalParameters()" ); + jj_consume_token(LPAREN); + if ((getToken( 1 ).kind != RPAREN)) { + p1 = FormalParameter(env); + result.add( p1 ); + label_20: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[23] = jj_gen; + break label_20; + } + jj_consume_token(COMMA); + p1 = FormalParameter(env); + result.add( p1 ); + } + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Parameter FormalParameter(Environment env) throws ParseException { + ModifierList p1; + TypeName p2; + String p3; + int p4; + DebugOut.println( "#FormalParameter()" ); + p1 = FormalParameterModifiersOpt(env); + p2 = Type(env); + p3 = Identifier(); + p4 = EmptyBracketsOpt(); + p2.addDimension( p4 ); + /* binds the parameter variable as the null type */ + env.bindVariable(p3, OJSystem.NULLTYPE); + {if (true) return new Parameter( p1, p2, p3 );} + throw new Error("Missing return statement in function"); + } + + final public ModifierList FormalParameterModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if (modifierCheck( env, getToken( 1 ) )) { + label_21: + while (true) { + if (jj_2_16(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_21; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ConstructorDeclaration ConstructorDeclaration(Environment base_env) throws ParseException { + Environment env = new ClosedEnvironment( base_env ); + ConstructorDeclaration result; + ModifierList p1; + String p2; + ParameterList p3; + TypeName[] p4; + ConstructorInvocation p5; + StatementList p6; + Hashtable sf; + + DebugOut.println( "#ConstructorDeclaration()" ); + p1 = ConstructorModifiersOpt(base_env); + p2 = Identifier(); + p3 = FormalParameters(env); + p4 = ThrowsPhraseOpt(base_env); + sf = OpenJavaDeclSuffixListOpt(env); + jj_consume_token(LBRACE); + p5 = ExplicitConstructorInvocationOpt(env); + p6 = BlockOrStatementListOpt(env); + jj_consume_token(RBRACE); + result = new ConstructorDeclaration( p1, p2, p3, p4, p5, p6 ); + result.setSuffixes( sf ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList ConstructorModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if (jj_2_17(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + label_22: + while (true) { + if (OpenJavaModifierLookahead( env )) { + ; + } else { + break label_22; + } + p2 = OpenJavaModifier(); + result.add( p2 ); + } + {if (true) return result;} + } else if (OpenJavaModifierLookahead( env )) { + label_23: + while (true) { + p2 = OpenJavaModifier(); + result.add( p2 ); + if (OpenJavaModifierLookahead( env )) { + ; + } else { + break label_23; + } + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ABSTRACT: + case FINAL: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case STATIC: + case SYNCHRONIZED: + case TRANSIENT: + case VOLATILE: + p1 = Modifier(); + result.add( p1 ); + label_24: + while (true) { + if (OpenJavaModifierLookahead( env )) { + ; + } else { + break label_24; + } + p2 = OpenJavaModifier(); + result.add( p2 ); + } + break; + default: + jj_la1[24] = jj_gen; + ; + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ConstructorInvocation ExplicitConstructorInvocationOpt(Environment env) throws ParseException { + ExpressionList p1; + Expression p2 = null; + + DebugOut.println( "#ExplicitConstructorInvocationOpt()" ); + if (jj_2_18(2147483647)) { + jj_consume_token(THIS); + p1 = Arguments(env); + jj_consume_token(SEMICOLON); + {if (true) return new ConstructorInvocation( p1 );} + } else if (ConstructorInvocationLookahead()) { + if ((getToken( 1 ).kind != SUPER)) { + p2 = PrimaryExpression(env); + jj_consume_token(DOT); + } else { + ; + } + jj_consume_token(SUPER); + p1 = Arguments(env); + jj_consume_token(SEMICOLON); + {if (true) return new ConstructorInvocation( p1, p2 );} + } else { + E(); + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public MemberInitializer MemberInitializer(Environment env) throws ParseException { + MemberInitializer result; + StatementList p1; + boolean is_static = false; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STATIC: + jj_consume_token(STATIC); + is_static = true; + break; + default: + jj_la1[25] = jj_gen; + ; + } + p1 = BlockedBody(env); + if (is_static) { + result = new MemberInitializer( p1, true ); + } else { + result = new MemberInitializer( p1 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + +/* + * Type, name and expression syntax follows. + */ + final public TypeName Type(Environment env) throws ParseException { + TypeName result; + String p1; + Hashtable p2; + int p3; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case VOID: + p1 = PrimitiveType(); + break; + case METACLASS: + case IDENTIFIER: + p1 = Name(); + break; + default: + jj_la1[26] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = OpenJavaTypeSuffixListOpt(env, p1); + p3 = EmptyBracketsOpt(); + result = new TypeName( p1, p3, p2 ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public String PrimitiveType() throws ParseException { + String result; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BOOLEAN: + jj_consume_token(BOOLEAN); + break; + case CHAR: + jj_consume_token(CHAR); + break; + case BYTE: + jj_consume_token(BYTE); + break; + case SHORT: + jj_consume_token(SHORT); + break; + case INT: + jj_consume_token(INT); + break; + case LONG: + jj_consume_token(LONG); + break; + case FLOAT: + jj_consume_token(FLOAT); + break; + case DOUBLE: + jj_consume_token(DOUBLE); + break; + case VOID: + jj_consume_token(VOID); + break; + default: + jj_la1[27] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + result = getToken( 0 ).image; + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public String Name() throws ParseException { + String p1; + StringBuffer strbuf = null; + p1 = Identifier(); + strbuf = new StringBuffer( p1 ); + label_25: + while (true) { + if (jj_2_19(2)) { + ; + } else { + break label_25; + } + jj_consume_token(DOT); + p1 = Identifier(); + strbuf.append( "." + p1 ); + } + {if (true) return strbuf.toString();} + throw new Error("Missing return statement in function"); + } + + final public TypeName TypeName(Environment env) throws ParseException { + TypeName result; + String p1; + Hashtable p2; + p1 = Name(); + p2 = OpenJavaTypeSuffixListOpt(env, p1); + result = new TypeName( p1, p2 ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public TypeName[] TypeNameList(Environment env) throws ParseException { + TypeName[] result; + TypeName p1; + Vector v = new Vector(); + p1 = TypeName(env); + v.addElement( p1 ); + label_26: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[28] = jj_gen; + break label_26; + } + jj_consume_token(COMMA); + p1 = TypeName(env); + v.addElement( p1 ); + } + result = new TypeName[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (TypeName) v.elementAt( i ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public TypeName[] TypeNameListOpt(Environment env) throws ParseException { + TypeName[] result; + TypeName p1; + Vector v = new Vector(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p1 = TypeName(env); + v.addElement( p1 ); + label_27: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[29] = jj_gen; + break label_27; + } + jj_consume_token(COMMA); + p1 = TypeName(env); + v.addElement( p1 ); + } + result = new TypeName[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (TypeName) v.elementAt( i ); + } + {if (true) return result;} + break; + default: + jj_la1[30] = jj_gen; + E(); + {if (true) return new TypeName[0];} + } + throw new Error("Missing return statement in function"); + } + +/* + * Expression syntax follows. + */ + final public Expression Expression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2 = null; + Expression p3 = null; + + DebugOut.println( "#Expression()" ); + p1 = ConditionalExpression(env); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ASSIGN: + case PLUSASSIGN: + case MINUSASSIGN: + case STARASSIGN: + case SLASHASSIGN: + case ANDASSIGN: + case ORASSIGN: + case XORASSIGN: + case REMASSIGN: + case LSHIFTASSIGN: + case RSIGNEDSHIFTASSIGN: + case RUNSIGNEDSHIFTASSIGN: + p2 = AssignmentOperator(); + p3 = Expression(env); + break; + default: + jj_la1[31] = jj_gen; + ; + } + if (p2 != null) { + result = new AssignmentExpression( p1, p2, p3 ); + } else { + result = p1; + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public AssignmentExpression AssignmentExpression(Environment env) throws ParseException { + Expression p1; + String p2; + Expression p3; + + DebugOut.println( "#AssignmentExpression()" ); + p1 = PrimaryExpression(env); + p2 = AssignmentOperator(); + p3 = Expression(env); + {if (true) return new AssignmentExpression( p1, p2, p3 );} + throw new Error("Missing return statement in function"); + } + + final public String AssignmentOperator() throws ParseException { + String result; + + DebugOut.println( "#AssignmentOperator()" ); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ASSIGN: + jj_consume_token(ASSIGN); + break; + case STARASSIGN: + jj_consume_token(STARASSIGN); + break; + case SLASHASSIGN: + jj_consume_token(SLASHASSIGN); + break; + case REMASSIGN: + jj_consume_token(REMASSIGN); + break; + case PLUSASSIGN: + jj_consume_token(PLUSASSIGN); + break; + case MINUSASSIGN: + jj_consume_token(MINUSASSIGN); + break; + case LSHIFTASSIGN: + jj_consume_token(LSHIFTASSIGN); + break; + case RSIGNEDSHIFTASSIGN: + jj_consume_token(RSIGNEDSHIFTASSIGN); + break; + case RUNSIGNEDSHIFTASSIGN: + jj_consume_token(RUNSIGNEDSHIFTASSIGN); + break; + case ANDASSIGN: + jj_consume_token(ANDASSIGN); + break; + case XORASSIGN: + jj_consume_token(XORASSIGN); + break; + case ORASSIGN: + jj_consume_token(ORASSIGN); + break; + default: + jj_la1[32] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + result = getToken( 0 ).image; + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression ConditionalExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + Expression p2 = null; + Expression p3 = null; + p1 = ConditionalOrExpression(env); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case HOOK: + jj_consume_token(HOOK); + p2 = Expression(env); + jj_consume_token(COLON); + p3 = ConditionalExpression(env); + break; + default: + jj_la1[33] = jj_gen; + ; + } + if (p2 != null) { + result = new ConditionalExpression( p1, p2, p3 ); + } else { + result = p1; + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression ConditionalOrExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = ConditionalAndExpression(env); + result = p1; + label_28: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SC_OR: + ; + break; + default: + jj_la1[34] = jj_gen; + break label_28; + } + jj_consume_token(SC_OR); + p2 = getToken( 0 ).image; + p3 = ConditionalAndExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression ConditionalAndExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = InclusiveOrExpression(env); + result = p1; + label_29: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SC_AND: + ; + break; + default: + jj_la1[35] = jj_gen; + break label_29; + } + jj_consume_token(SC_AND); + p2 = getToken( 0 ).image; + p3 = InclusiveOrExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression InclusiveOrExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = ExclusiveOrExpression(env); + result = p1; + label_30: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BIT_OR: + ; + break; + default: + jj_la1[36] = jj_gen; + break label_30; + } + jj_consume_token(BIT_OR); + p2 = getToken( 0 ).image; + p3 = ExclusiveOrExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression ExclusiveOrExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = AndExpression(env); + result = p1; + label_31: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case XOR: + ; + break; + default: + jj_la1[37] = jj_gen; + break label_31; + } + jj_consume_token(XOR); + p2 = getToken( 0 ).image; + p3 = AndExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression AndExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = EqualityExpression(env); + result = p1; + label_32: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BIT_AND: + ; + break; + default: + jj_la1[38] = jj_gen; + break label_32; + } + jj_consume_token(BIT_AND); + p2 = getToken( 0 ).image; + p3 = EqualityExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression EqualityExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + + DebugOut.println( "#EqualityExpression()" ); + p1 = InstanceofExpression(env); + result = p1; + label_33: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EQ: + case NE: + ; + break; + default: + jj_la1[39] = jj_gen; + break label_33; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EQ: + jj_consume_token(EQ); + break; + case NE: + jj_consume_token(NE); + break; + default: + jj_la1[40] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = getToken( 0 ).image; + p3 = InstanceofExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression InstanceofExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + TypeName p2 = null; + p1 = RelationalExpression(env); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INSTANCEOF: + jj_consume_token(INSTANCEOF); + p2 = Type(env); + break; + default: + jj_la1[41] = jj_gen; + ; + } + if (p2 != null) { + result = new InstanceofExpression( p1, p2 ); + } else { + result = p1; + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression RelationalExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = ShiftExpression(env); + result = p1; + label_34: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case GT: + case LT: + case LE: + case GE: + ; + break; + default: + jj_la1[42] = jj_gen; + break label_34; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LT: + jj_consume_token(LT); + break; + case GT: + jj_consume_token(GT); + break; + case LE: + jj_consume_token(LE); + break; + case GE: + jj_consume_token(GE); + break; + default: + jj_la1[43] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = getToken( 0 ).image; + p3 = ShiftExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression ShiftExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = AdditiveExpression(env); + result = p1; + label_35: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LSHIFT: + case RSIGNEDSHIFT: + case RUNSIGNEDSHIFT: + ; + break; + default: + jj_la1[44] = jj_gen; + break label_35; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LSHIFT: + jj_consume_token(LSHIFT); + break; + case RSIGNEDSHIFT: + jj_consume_token(RSIGNEDSHIFT); + break; + case RUNSIGNEDSHIFT: + jj_consume_token(RUNSIGNEDSHIFT); + break; + default: + jj_la1[45] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = getToken( 0 ).image; + p3 = AdditiveExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression AdditiveExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = MultiplicativeExpression(env); + result = p1; + label_36: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PLUS: + case MINUS: + ; + break; + default: + jj_la1[46] = jj_gen; + break label_36; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PLUS: + jj_consume_token(PLUS); + break; + case MINUS: + jj_consume_token(MINUS); + break; + default: + jj_la1[47] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = getToken( 0 ).image; + p3 = MultiplicativeExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression MultiplicativeExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = UnaryExpression(env); + result = p1; + label_37: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STAR: + case SLASH: + case REM: + ; + break; + default: + jj_la1[48] = jj_gen; + break label_37; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STAR: + jj_consume_token(STAR); + break; + case SLASH: + jj_consume_token(SLASH); + break; + case REM: + jj_consume_token(REM); + break; + default: + jj_la1[49] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = getToken( 0 ).image; + p3 = UnaryExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression UnaryExpression(Environment env) throws ParseException { + int p1; + Expression p2; + if (jj_2_20(2147483647)) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PLUS: + jj_consume_token(PLUS); + p1 = UnaryExpression.PLUS; + break; + case MINUS: + jj_consume_token(MINUS); + p1 = UnaryExpression.MINUS; + break; + default: + jj_la1[50] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = UnaryExpression(env); + {if (true) return new UnaryExpression( p1, p2 );} + } else if (jj_2_21(2147483647)) { + p2 = PreIncrementExpression(env); + {if (true) return p2;} + } else if (jj_2_22(1)) { + p2 = UnaryExpressionNotPlusMinus(env); + {if (true) return p2;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public Expression PreIncrementExpression(Environment env) throws ParseException { + int p1; + Expression p2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + jj_consume_token(INCR); + p1 = UnaryExpression.PRE_INCREMENT; + break; + case DECR: + jj_consume_token(DECR); + p1 = UnaryExpression.PRE_DECREMENT; + break; + default: + jj_la1[51] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = PrimaryExpression(env); + {if (true) return new UnaryExpression( p1, p2 );} + throw new Error("Missing return statement in function"); + } + + final public Expression UnaryExpressionNotPlusMinus(Environment env) throws ParseException { + int p1; + Expression p2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BANG: + case TILDE: + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case TILDE: + jj_consume_token(TILDE); + p1 = UnaryExpression.BIT_NOT; + break; + case BANG: + jj_consume_token(BANG); + p1 = UnaryExpression.NOT; + break; + default: + jj_la1[52] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = UnaryExpression(env); + {if (true) return new UnaryExpression( p1, p2 );} + break; + default: + jj_la1[53] = jj_gen; + if (jj_2_23(2147483647)) { + p2 = CastExpression(env); + {if (true) return p2;} + } else if (jj_2_24(1)) { + p2 = PostfixExpression(env); + {if (true) return p2;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + + final public void CastLookahead(Environment env) throws ParseException { + if (jj_2_25(2)) { + jj_consume_token(LPAREN); + PrimitiveType(); + } else if (jj_2_26(2147483647)) { + jj_consume_token(LPAREN); + Name(); + jj_consume_token(LBRACKET); + jj_consume_token(RBRACKET); + } else if (jj_2_27(2147483647)) { + jj_consume_token(LPAREN); + Name(); + jj_consume_token(RPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case TILDE: + jj_consume_token(TILDE); + break; + case BANG: + jj_consume_token(BANG); + break; + case LPAREN: + jj_consume_token(LPAREN); + break; + case METACLASS: + case IDENTIFIER: + Identifier(); + break; + case THIS: + jj_consume_token(THIS); + break; + case SUPER: + jj_consume_token(SUPER); + break; + case NEW: + jj_consume_token(NEW); + break; + case FALSE: + case NULL: + case TRUE: + case INTEGER_LITERAL: + case LONG_LITERAL: + case DOUBLE_FLOATING_POINT_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + Literal(); + break; + default: + jj_la1[54] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LPAREN: + jj_consume_token(LPAREN); + Name(); + Identifier(); + break; + default: + jj_la1[55] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } + + final public Expression PostfixExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + int p2 = -1; + p1 = PrimaryExpression(env); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + case DECR: + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + jj_consume_token(INCR); + p2 = UnaryExpression.POST_INCREMENT; + break; + case DECR: + jj_consume_token(DECR); + p2 = UnaryExpression.POST_DECREMENT; + break; + default: + jj_la1[56] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + break; + default: + jj_la1[57] = jj_gen; + ; + } + if (p2 != -1) { + result = new UnaryExpression( p1, p2 ); + } else { + result = p1; + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public CastExpression CastExpression(Environment env) throws ParseException { + TypeName p1; + Expression p2; + + DebugOut.println( "#CastExpression()" ); + if (jj_2_28(2147483647)) { + jj_consume_token(LPAREN); + p1 = Type(env); + jj_consume_token(RPAREN); + p2 = UnaryExpression(env); + {if (true) return new CastExpression( p1, p2 );} + } else if (jj_2_29(2147483647)) { + jj_consume_token(LPAREN); + p1 = Type(env); + jj_consume_token(RPAREN); + p2 = UnaryExpressionNotPlusMinus(env); + {if (true) return new CastExpression( p1, p2 );} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public Expression SelfAccess(Environment env) throws ParseException { + Expression result; + String p1 = null; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p1 = Name(); + jj_consume_token(DOT); + break; + default: + jj_la1[58] = jj_gen; + ; + } + jj_consume_token(THIS); + if (p1 != null) { + result = SelfAccess.makeThis( p1 ); + } else { + result = SelfAccess.constantThis(); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ClassLiteral ClassLiteral(Environment env) throws ParseException { + TypeName p1; + p1 = Type(env); + jj_consume_token(DOT); + jj_consume_token(CLASS); + {if (true) return new ClassLiteral( p1 );} + throw new Error("Missing return statement in function"); + } + + final public Expression PrimaryExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + Expression p2; + Expression p3; + String p4; + ExpressionList p5; + p1 = PrimaryPrefix(env); + result = p1; + label_38: + while (true) { + if (jj_2_30(2147483647)) { + ; + } else { + break label_38; + } + if (jj_2_31(2147483647)) { + jj_consume_token(DOT); + p2 = AllocationExpression(env); + AllocationExpression alloc = (AllocationExpression) p2; + alloc.setEncloser( result ); + result = alloc; + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACKET: + jj_consume_token(LBRACKET); + p3 = Expression(env); + jj_consume_token(RBRACKET); + result = new ArrayAccess( result, p3 ); + break; + case DOT: + jj_consume_token(DOT); + p4 = Identifier(); + result = new FieldAccess( result, p4 ); + break; + case LPAREN: + p5 = Arguments(env); + FieldAccess base = (FieldAccess) result; + Expression expr = base.getReferenceExpr(); + String name = base.getName(); + result = new MethodCall( expr, name, p5 ); + break; + default: + jj_la1[59] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression PrimaryPrefix(Environment env) throws ParseException { + Expression p1; + String p2; + + DebugOut.println( "#PrimaryPrefix()" ); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case FALSE: + case NULL: + case TRUE: + case INTEGER_LITERAL: + case LONG_LITERAL: + case DOUBLE_FLOATING_POINT_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + p1 = Literal(); + {if (true) return p1;} + break; + default: + jj_la1[60] = jj_gen; + if (jj_2_32(2147483647)) { + p1 = SelfAccess(env); + {if (true) return p1;} + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SUPER: + jj_consume_token(SUPER); + jj_consume_token(DOT); + p2 = Identifier(); + {if (true) return new FieldAccess( SelfAccess.constantSuper(), p2 );} + break; + case LPAREN: + jj_consume_token(LPAREN); + p1 = Expression(env); + jj_consume_token(RPAREN); + {if (true) return p1;} + break; + case NEW: + p1 = AllocationExpression(env); + {if (true) return p1;} + break; + default: + jj_la1[61] = jj_gen; + if (ClassLiteralLookahead()) { + p1 = ClassLiteral(env); + {if (true) return p1;} + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p1 = TempFieldAccess(env); + {if (true) return p1;} + break; + default: + jj_la1[62] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } + } + } + throw new Error("Missing return statement in function"); + } + + final public FieldAccess TempFieldAccess(Environment env) throws ParseException { + FieldAccess result; + String p1; + StringBuffer strbuf = null; + p1 = Identifier(); + label_39: + while (true) { + if (jj_2_33(2147483647)) { + ; + } else { + break label_39; + } + jj_consume_token(DOT); + if (strbuf == null) { + strbuf = new StringBuffer( p1 ); + } else { + strbuf.append( "." + p1 ); + } + p1 = Identifier(); + } + if (strbuf == null || strbuf.length() == 0) { + result = new FieldAccess( (Variable) null, p1 ); + } else { + Variable var = new Variable( strbuf.toString() ); + result = new FieldAccess( var, p1 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Literal Literal() throws ParseException { + String p1; + Literal p2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + jj_consume_token(INTEGER_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.INTEGER, p1 );} + break; + case LONG_LITERAL: + jj_consume_token(LONG_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.LONG, p1 );} + break; + case FLOATING_POINT_LITERAL: + jj_consume_token(FLOATING_POINT_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.FLOAT, p1 );} + break; + case DOUBLE_FLOATING_POINT_LITERAL: + jj_consume_token(DOUBLE_FLOATING_POINT_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.DOUBLE, p1 );} + break; + case CHARACTER_LITERAL: + jj_consume_token(CHARACTER_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.CHARACTER, p1 );} + break; + case STRING_LITERAL: + jj_consume_token(STRING_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.STRING, p1 );} + break; + case TRUE: + jj_consume_token(TRUE); + {if (true) return Literal.constantTrue();} + break; + case FALSE: + jj_consume_token(FALSE); + {if (true) return Literal.constantFalse();} + break; + case NULL: + jj_consume_token(NULL); + {if (true) return Literal.constantNull();} + break; + default: + jj_la1[63] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public ExpressionList Arguments(Environment env) throws ParseException { + ExpressionList result = new ExpressionList(); + Expression p1; + + DebugOut.println( "#Arguments()" ); + jj_consume_token(LPAREN); + if (jj_2_34(1)) { + p1 = Expression(env); + result.add( p1 ); + label_40: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[64] = jj_gen; + break label_40; + } + jj_consume_token(COMMA); + p1 = Expression(env); + result.add( p1 ); + } + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression AllocationExpression(Environment env) throws ParseException { + Expression result; + AllocationExpression aloc_result; + TypeName p1; + ArrayAllocationExpression p2; + ExpressionList p3; + MemberDeclarationList p4 = null; + + DebugOut.println( "#AllocationExpression()" ); + if (jj_2_36(2147483647)) { + jj_consume_token(NEW); + p1 = TypeWithoutDims(env); + p2 = ArrayDimsAndInits(env, p1); + result = p2; + {if (true) return result;} + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case NEW: + jj_consume_token(NEW); + p1 = TypeWithoutDims(env); + if (jj_2_35(2147483647)) { + p2 = ArrayDimsAndInits(env, p1); + result = p2; + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LPAREN: + p3 = Arguments(env); + aloc_result = new AllocationExpression( p1, p3, p4 ); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p4 = ClassBody(new ClassEnvironment( env )); + aloc_result.setClassBody( p4 ); + break; + default: + jj_la1[65] = jj_gen; + ; + } + result = aloc_result; + break; + default: + jj_la1[66] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return result;} + break; + default: + jj_la1[67] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + + final public TypeName TypeWithoutDims(Environment env) throws ParseException { + String p1; + Hashtable p2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case VOID: + p1 = PrimitiveType(); + break; + case METACLASS: + case IDENTIFIER: + p1 = Name(); + break; + default: + jj_la1[68] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = OpenJavaTypeSuffixListOpt(env, p1); + {if (true) return new TypeName( p1, p2 );} + throw new Error("Missing return statement in function"); + } + + final public ArrayAllocationExpression ArrayDimsAndInits(Environment env, TypeName type) throws ParseException { + Expression p1; + int p2; + ArrayInitializer p3; + ExpressionList exprs = new ExpressionList(); + if (jj_2_37(2147483647)) { + p2 = EmptyBracketsOpt(); + p3 = ArrayInitializer(env); + for (int i = 0; i < p2; ++i) exprs.add( null ); + {if (true) return new ArrayAllocationExpression( type, exprs, p3 );} + } else if (jj_2_38(2147483647)) { + label_41: + while (true) { + jj_consume_token(LBRACKET); + p1 = Expression(env); + exprs.add( p1 ); + jj_consume_token(RBRACKET); + if ((getToken( 1 ).kind == LBRACKET + && getToken( 2 ).kind != RBRACKET)) { + ; + } else { + break label_41; + } + } + p2 = EmptyBracketsOpt(); + for (int i = 0; i < p2; ++i) exprs.add( null ); + {if (true) return new ArrayAllocationExpression( type, exprs );} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public StatementList BlockedBody(Environment env) throws ParseException { + StatementList p1; + jj_consume_token(LBRACE); + p1 = BlockOrStatementListOpt(env); + jj_consume_token(RBRACE); + {if (true) return p1;} + throw new Error("Missing return statement in function"); + } + +/* + * Statement syntax follows. + */ + final public Statement Statement(Environment env) throws ParseException { + Statement p1; + if (jj_2_39(2147483647)) { + p1 = LabeledStatement(env); + {if (true) return p1;} + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p1 = Block(env); + {if (true) return p1;} + break; + case SEMICOLON: + p1 = EmptyStatement(env); + {if (true) return p1;} + break; + case SWITCH: + p1 = SwitchStatement(env); + {if (true) return p1;} + break; + case IF: + p1 = IfStatement(env); + {if (true) return p1;} + break; + case WHILE: + p1 = WhileStatement(env); + {if (true) return p1;} + break; + case DO: + p1 = DoWhileStatement(env); + {if (true) return p1;} + break; + case FOR: + p1 = ForStatement(env); + {if (true) return p1;} + break; + case BREAK: + p1 = BreakStatement(env); + {if (true) return p1;} + break; + case CONTINUE: + p1 = ContinueStatement(env); + {if (true) return p1;} + break; + case RETURN: + p1 = ReturnStatement(env); + {if (true) return p1;} + break; + case THROW: + p1 = ThrowStatement(env); + {if (true) return p1;} + break; + case SYNCHRONIZED: + p1 = SynchronizedStatement(env); + {if (true) return p1;} + break; + case TRY: + p1 = TryStatement(env); + {if (true) return p1;} + break; + default: + jj_la1[69] = jj_gen; + if (jj_2_40(1)) { + p1 = ExpressionStatement(env); + {if (true) return p1;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + } + throw new Error("Missing return statement in function"); + } + + final public LabeledStatement LabeledStatement(Environment env) throws ParseException { + String p1; + Statement p2; + + DebugOut.println( "#LabeledStatement()" ); + p1 = Identifier(); + jj_consume_token(COLON); + p2 = Statement(env); + {if (true) return new LabeledStatement( p1, p2 );} + throw new Error("Missing return statement in function"); + } + + final public Block Block(Environment env) throws ParseException { + StatementList p1; + DebugOut.println( "#Block()" ); + jj_consume_token(LBRACE); + p1 = BlockOrStatementListOpt(env); + jj_consume_token(RBRACE); + {if (true) return new Block( p1 );} + throw new Error("Missing return statement in function"); + } + + final public StatementList BlockOrStatementListOpt(Environment env) throws ParseException { + StatementList result = new StatementList(); + StatementList p1; + if ((getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF + && getToken( 1 ).kind != CASE + && getToken( 1 ).kind != _DEFAULT )) { + label_42: + while (true) { + p1 = BlockOrStatement(env); + result.addAll( p1 ); + if ((getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF + && getToken( 1 ).kind != CASE + && getToken( 1 ).kind != _DEFAULT )) { + ; + } else { + break label_42; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public StatementList BlockOrStatement(Environment env) throws ParseException { + Statement p1; + StatementList p2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case CLASS: + p1 = UnmodifiedClassDeclaration(new ClassEnvironment( env )); + {if (true) return new StatementList( p1 );} + break; + default: + jj_la1[70] = jj_gen; + if (LocalVariableDeclarationLookahead( env )) { + p2 = LocalVariableDeclaration(env); + jj_consume_token(SEMICOLON); + {if (true) return p2;} + } else if (jj_2_41(1)) { + p1 = Statement(env); + {if (true) return new StatementList( p1 );} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + + final public StatementList LocalVariableDeclaration(Environment env) throws ParseException { + StatementList result = new StatementList(); + ModifierList p1; + TypeName p2; + VariableDeclarator p3; + TypeName tspec; + String vname; + VariableInitializer vinit; + DebugOut.println( "#LocalVariableDeclaration()" ); + p1 = VariableModifiersOpt(env); + p2 = Type(env); + p3 = VariableDeclarator(env); + tspec = (TypeName) p2.makeRecursiveCopy(); + tspec.addDimension( p3.getDimension() ); + vname = p3.getVariable(); + vinit = p3.getInitializer(); + result.add( new VariableDeclaration( p1, tspec, vname, vinit ) ); + label_43: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[71] = jj_gen; + break label_43; + } + jj_consume_token(COMMA); + p3 = VariableDeclarator(env); + tspec = (TypeName) p2.makeRecursiveCopy(); + tspec.addDimension( p3.getDimension() ); + vname = p3.getVariable(); + vinit = p3.getInitializer(); + result.add( new VariableDeclaration( p1, tspec, vname, vinit ) ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList VariableModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if (modifierCheck( env, getToken( 1 ) )) { + label_44: + while (true) { + if (jj_2_42(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_44; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public EmptyStatement EmptyStatement(Environment env) throws ParseException { + DebugOut.println( "#EmptyStatement()" ); + jj_consume_token(SEMICOLON); + {if (true) return new EmptyStatement();} + throw new Error("Missing return statement in function"); + } + + final public ExpressionStatement ExpressionStatement(Environment env) throws ParseException { + Expression p1; + + DebugOut.println( "#ExpressionStatement()" ); + p1 = StatementExpression(env); + jj_consume_token(SEMICOLON); + {if (true) return new ExpressionStatement( p1 );} + throw new Error("Missing return statement in function"); + } + + final public Expression StatementExpression(Environment env) throws ParseException { + Expression p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + case DECR: + p1 = PreIncrementExpression(env); + {if (true) return p1;} + break; + default: + jj_la1[72] = jj_gen; + if (AssignmentLookahead()) { + p1 = AssignmentExpression(env); + {if (true) return p1;} + } else if (jj_2_43(1)) { + p1 = PostfixExpression(env); + {if (true) return p1;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + + final public SwitchStatement SwitchStatement(Environment env) throws ParseException { + Expression p1; + Expression p2; + StatementList p3; + CaseGroupList cplist = new CaseGroupList(); + ExpressionList exprs; + + DebugOut.println( "#SwitchStatement()" ); + jj_consume_token(SWITCH); + jj_consume_token(LPAREN); + p1 = Expression(env); + jj_consume_token(RPAREN); + jj_consume_token(LBRACE); + label_45: + while (true) { + if (jj_2_44(2147483647)) { + ; + } else { + break label_45; + } + exprs = new ExpressionList(); + label_46: + while (true) { + p2 = SwitchLabel(env); + exprs.add( p2 ); + if (jj_2_45(2147483647)) { + ; + } else { + break label_46; + } + } + p3 = BlockOrStatementListOpt(env); + cplist.add( new CaseGroup( exprs, p3 ) ); + } + jj_consume_token(RBRACE); + {if (true) return new SwitchStatement( p1, cplist );} + throw new Error("Missing return statement in function"); + } + + final public Expression SwitchLabel(Environment env) throws ParseException { + Expression p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case CASE: + jj_consume_token(CASE); + p1 = Expression(env); + jj_consume_token(COLON); + {if (true) return p1;} + break; + case _DEFAULT: + jj_consume_token(_DEFAULT); + jj_consume_token(COLON); + {if (true) return null;} + break; + default: + jj_la1[73] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public IfStatement IfStatement(Environment env) throws ParseException { + IfStatement result; + Expression p1; + StatementList p2; + Statement p3; + StatementList true_part; + StatementList false_part = null; + + DebugOut.println( "#IfStatement()" ); + jj_consume_token(IF); + jj_consume_token(LPAREN); + p1 = Expression(env); + jj_consume_token(RPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p2 = BlockedBody(env); + true_part = p2; + break; + default: + jj_la1[74] = jj_gen; + if (jj_2_46(1)) { + p3 = Statement(env); + true_part = new StatementList( p3 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ELSE: + jj_consume_token(ELSE); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p2 = BlockedBody(env); + false_part = p2; + break; + default: + jj_la1[75] = jj_gen; + if (jj_2_47(1)) { + p3 = Statement(env); + false_part = new StatementList( p3 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + break; + default: + jj_la1[76] = jj_gen; + ; + } + {if (true) return new IfStatement( p1, true_part, false_part );} + throw new Error("Missing return statement in function"); + } + + final public WhileStatement WhileStatement(Environment env) throws ParseException { + Expression p1; + StatementList p2; + Statement p3; + StatementList body; + + DebugOut.println( "#WhileStatement()" ); + jj_consume_token(WHILE); + jj_consume_token(LPAREN); + p1 = Expression(env); + jj_consume_token(RPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p2 = BlockedBody(env); + body = p2; + break; + default: + jj_la1[77] = jj_gen; + if (jj_2_48(1)) { + p3 = Statement(env); + body = new StatementList( p3 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return new WhileStatement( p1, body );} + throw new Error("Missing return statement in function"); + } + + final public DoWhileStatement DoWhileStatement(Environment env) throws ParseException { + StatementList p1; + Statement p2; + Expression p3; + StatementList body; + + DebugOut.println( "#DoWhileStatement()" ); + jj_consume_token(DO); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p1 = BlockedBody(env); + body = p1; + break; + default: + jj_la1[78] = jj_gen; + if (jj_2_49(1)) { + p2 = Statement(env); + body = new StatementList( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + jj_consume_token(WHILE); + jj_consume_token(LPAREN); + p3 = Expression(env); + jj_consume_token(RPAREN); + jj_consume_token(SEMICOLON); + {if (true) return new DoWhileStatement( body, p3 );} + throw new Error("Missing return statement in function"); + } + + final public ForStatement ForStatement(Environment env) throws ParseException { + ForStatement result; + TypeName p1 = null; + VariableDeclarator[] p2 = null; + ExpressionList p3 = null; + Expression p4 = null; + ExpressionList p5 = null; + StatementList p6; + Statement p7; + StatementList body; + + DebugOut.println( "#ForStatement()" ); + jj_consume_token(FOR); + jj_consume_token(LPAREN); + if ((getToken( 1 ).kind != SEMICOLON)) { + if (LocalVariableDeclarationLookahead( env )) { + p1 = Type(env); + p2 = VariableDeclaratorList(env); + } else if (jj_2_50(1)) { + p3 = StatementExpressionList(env); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + jj_consume_token(SEMICOLON); + if ((getToken( 1 ).kind != SEMICOLON)) { + p4 = Expression(env); + } else { + ; + } + jj_consume_token(SEMICOLON); + if ((getToken( 1 ).kind != RPAREN)) { + p5 = StatementExpressionList(env); + } else { + ; + } + jj_consume_token(RPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p6 = BlockedBody(env); + body = p6; + break; + default: + jj_la1[79] = jj_gen; + if (jj_2_51(1)) { + p7 = Statement(env); + body = new StatementList( p7 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + if (p1 != null) { + result = new ForStatement( p1, p2, p4, p5, body ); + } else if (p3 != null) { + result = new ForStatement( p3, p4, p5, body ); + } else { + result = new ForStatement( new ExpressionList(), p4, p5, body ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public VariableDeclarator[] VariableDeclaratorList(Environment env) throws ParseException { + VariableDeclarator[] result; + VariableDeclarator p1; + Vector v = new Vector(); + + DebugOut.println( "#LocalVariableDeclaration()" ); + p1 = VariableDeclarator(env); + v.addElement( p1 ); + label_47: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[80] = jj_gen; + break label_47; + } + jj_consume_token(COMMA); + p1 = VariableDeclarator(env); + v.addElement( p1 ); + } + result = new VariableDeclarator[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (VariableDeclarator) v.elementAt( i ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ExpressionList StatementExpressionList(Environment env) throws ParseException { + ExpressionList result = new ExpressionList(); + Expression p1; + p1 = StatementExpression(env); + result.add( p1 ); + label_48: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[81] = jj_gen; + break label_48; + } + jj_consume_token(COMMA); + p1 = StatementExpression(env); + result.add( p1 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public BreakStatement BreakStatement(Environment env) throws ParseException { + BreakStatement result; + String p1 = null; + + DebugOut.println( "#BreakStatement()" ); + jj_consume_token(BREAK); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p1 = Identifier(); + break; + default: + jj_la1[82] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); + if (p1 != null) { + result = new BreakStatement( p1 ); + } else { + result = new BreakStatement(); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ContinueStatement ContinueStatement(Environment env) throws ParseException { + ContinueStatement result; + String p1 = null; + + DebugOut.println( "#ContinueStatement()" ); + jj_consume_token(CONTINUE); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p1 = Identifier(); + break; + default: + jj_la1[83] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); + if (p1 != null) { + result = new ContinueStatement( p1 ); + } else { + result = new ContinueStatement(); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ReturnStatement ReturnStatement(Environment env) throws ParseException { + ReturnStatement result; + Expression p1 = null; + + DebugOut.println( "#ReturnStatement()" ); + jj_consume_token(RETURN); + if ((getToken(1).kind != SEMICOLON)) { + p1 = Expression(env); + } else { + ; + } + jj_consume_token(SEMICOLON); + if (p1 != null) { + result = new ReturnStatement( p1 ); + } else { + result = new ReturnStatement(); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ThrowStatement ThrowStatement(Environment env) throws ParseException { + Statement result; + Expression p1; + + DebugOut.println( "#ThrowStatement()" ); + jj_consume_token(THROW); + p1 = Expression(env); + jj_consume_token(SEMICOLON); + {if (true) return new ThrowStatement( p1 );} + throw new Error("Missing return statement in function"); + } + + final public SynchronizedStatement SynchronizedStatement(Environment env) throws ParseException { + Expression p1; + StatementList p2; + + DebugOut.println( "#SynchronizedStatement()" ); + jj_consume_token(SYNCHRONIZED); + jj_consume_token(LPAREN); + p1 = Expression(env); + jj_consume_token(RPAREN); + p2 = BlockedBody(env); + {if (true) return new SynchronizedStatement( p1, p2 );} + throw new Error("Missing return statement in function"); + } + + final public TryStatement TryStatement(Environment base_env) throws ParseException { + Environment env = new ClosedEnvironment( base_env ); + TryStatement result; + StatementList p1; + Parameter p2; + StatementList p3; + StatementList p4 = null; + CatchList catches = new CatchList(); + + DebugOut.println( "#TryStatement()" ); + jj_consume_token(TRY); + p1 = BlockedBody(env); + label_49: + while (true) { + if (jj_2_52(2147483647)) { + ; + } else { + break label_49; + } + env = new ClosedEnvironment( base_env ); + jj_consume_token(CATCH); + jj_consume_token(LPAREN); + p2 = FormalParameter(env); + jj_consume_token(RPAREN); + p3 = BlockedBody(env); + catches.add( new CatchBlock( p2, p3 ) ); + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case FINALLY: + jj_consume_token(FINALLY); + p4 = BlockedBody(new ClosedEnvironment( base_env )); + break; + default: + jj_la1[84] = jj_gen; + ; + } + result = new TryStatement( p1, catches, p4 ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final private boolean jj_2_1(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_1(); + jj_save(0, xla); + return retval; + } + + final private boolean jj_2_2(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_2(); + jj_save(1, xla); + return retval; + } + + final private boolean jj_2_3(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_3(); + jj_save(2, xla); + return retval; + } + + final private boolean jj_2_4(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_4(); + jj_save(3, xla); + return retval; + } + + final private boolean jj_2_5(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_5(); + jj_save(4, xla); + return retval; + } + + final private boolean jj_2_6(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_6(); + jj_save(5, xla); + return retval; + } + + final private boolean jj_2_7(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_7(); + jj_save(6, xla); + return retval; + } + + final private boolean jj_2_8(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_8(); + jj_save(7, xla); + return retval; + } + + final private boolean jj_2_9(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_9(); + jj_save(8, xla); + return retval; + } + + final private boolean jj_2_10(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_10(); + jj_save(9, xla); + return retval; + } + + final private boolean jj_2_11(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_11(); + jj_save(10, xla); + return retval; + } + + final private boolean jj_2_12(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_12(); + jj_save(11, xla); + return retval; + } + + final private boolean jj_2_13(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_13(); + jj_save(12, xla); + return retval; + } + + final private boolean jj_2_14(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_14(); + jj_save(13, xla); + return retval; + } + + final private boolean jj_2_15(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_15(); + jj_save(14, xla); + return retval; + } + + final private boolean jj_2_16(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_16(); + jj_save(15, xla); + return retval; + } + + final private boolean jj_2_17(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_17(); + jj_save(16, xla); + return retval; + } + + final private boolean jj_2_18(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_18(); + jj_save(17, xla); + return retval; + } + + final private boolean jj_2_19(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_19(); + jj_save(18, xla); + return retval; + } + + final private boolean jj_2_20(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_20(); + jj_save(19, xla); + return retval; + } + + final private boolean jj_2_21(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_21(); + jj_save(20, xla); + return retval; + } + + final private boolean jj_2_22(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_22(); + jj_save(21, xla); + return retval; + } + + final private boolean jj_2_23(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_23(); + jj_save(22, xla); + return retval; + } + + final private boolean jj_2_24(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_24(); + jj_save(23, xla); + return retval; + } + + final private boolean jj_2_25(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_25(); + jj_save(24, xla); + return retval; + } + + final private boolean jj_2_26(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_26(); + jj_save(25, xla); + return retval; + } + + final private boolean jj_2_27(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_27(); + jj_save(26, xla); + return retval; + } + + final private boolean jj_2_28(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_28(); + jj_save(27, xla); + return retval; + } + + final private boolean jj_2_29(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_29(); + jj_save(28, xla); + return retval; + } + + final private boolean jj_2_30(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_30(); + jj_save(29, xla); + return retval; + } + + final private boolean jj_2_31(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_31(); + jj_save(30, xla); + return retval; + } + + final private boolean jj_2_32(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_32(); + jj_save(31, xla); + return retval; + } + + final private boolean jj_2_33(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_33(); + jj_save(32, xla); + return retval; + } + + final private boolean jj_2_34(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_34(); + jj_save(33, xla); + return retval; + } + + final private boolean jj_2_35(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_35(); + jj_save(34, xla); + return retval; + } + + final private boolean jj_2_36(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_36(); + jj_save(35, xla); + return retval; + } + + final private boolean jj_2_37(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_37(); + jj_save(36, xla); + return retval; + } + + final private boolean jj_2_38(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_38(); + jj_save(37, xla); + return retval; + } + + final private boolean jj_2_39(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_39(); + jj_save(38, xla); + return retval; + } + + final private boolean jj_2_40(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_40(); + jj_save(39, xla); + return retval; + } + + final private boolean jj_2_41(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_41(); + jj_save(40, xla); + return retval; + } + + final private boolean jj_2_42(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_42(); + jj_save(41, xla); + return retval; + } + + final private boolean jj_2_43(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_43(); + jj_save(42, xla); + return retval; + } + + final private boolean jj_2_44(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_44(); + jj_save(43, xla); + return retval; + } + + final private boolean jj_2_45(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_45(); + jj_save(44, xla); + return retval; + } + + final private boolean jj_2_46(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_46(); + jj_save(45, xla); + return retval; + } + + final private boolean jj_2_47(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_47(); + jj_save(46, xla); + return retval; + } + + final private boolean jj_2_48(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_48(); + jj_save(47, xla); + return retval; + } + + final private boolean jj_2_49(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_49(); + jj_save(48, xla); + return retval; + } + + final private boolean jj_2_50(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_50(); + jj_save(49, xla); + return retval; + } + + final private boolean jj_2_51(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_51(); + jj_save(50, xla); + return retval; + } + + final private boolean jj_2_52(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_52(); + jj_save(51, xla); + return retval; + } + + final private boolean jj_3R_133() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_31() { + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(NEW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_14() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_101() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_30() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_100()) { + jj_scanpos = xsp; + if (jj_3R_101()) { + jj_scanpos = xsp; + if (jj_3R_102()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_100() { + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_13() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_52() { + if (jj_scan_token(CATCH)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_132() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_135() { + if (jj_3R_166()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_86() { + if (jj_scan_token(INTERFACE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_141() { + if (jj_3R_178()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_194() { + if (jj_scan_token(TRY)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_85() { + if (jj_scan_token(CLASS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_84() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_131()) { + jj_scanpos = xsp; + if (jj_3R_132()) { + jj_scanpos = xsp; + if (jj_3R_133()) { + jj_scanpos = xsp; + if (jj_3R_134()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_131() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_12() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_84()) { jj_scanpos = xsp; break; } + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } + xsp = jj_scanpos; + if (jj_3R_85()) { + jj_scanpos = xsp; + if (jj_3R_86()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_207() { + if (jj_3R_141()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_220() { + if (jj_3R_228()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_193() { + if (jj_scan_token(SYNCHRONIZED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_177() { + if (jj_3R_198()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_54() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_176() { + if (jj_scan_token(NEW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_225() { + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_53() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_41() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_218() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_225()) jj_scanpos = xsp; + else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(THIS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_29() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_192() { + if (jj_scan_token(THROW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_87() { + if (jj_3R_135()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_28() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_98()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_175() { + if (jj_scan_token(SUPER)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_83() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_197() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_52() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_3() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_52()) { + jj_scanpos = xsp; + if (jj_3R_53()) { + jj_scanpos = xsp; + if (jj_3R_54()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_80() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_196() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_169() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_196()) { + jj_scanpos = xsp; + if (jj_3R_197()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_174() { + if (jj_scan_token(THIS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_82() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_191() { + if (jj_scan_token(RETURN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_79() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_173() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_81() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_11() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_78()) { + jj_scanpos = xsp; + if (jj_3R_79()) { + jj_scanpos = xsp; + if (jj_3R_80()) { + jj_scanpos = xsp; + if (jj_3R_81()) { + jj_scanpos = xsp; + if (jj_3R_82()) { + jj_scanpos = xsp; + if (jj_3R_83()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_78() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_172() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_182() { + if (jj_scan_token(LBRACE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_97() { + if (jj_3R_141()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_171() { + if (jj_scan_token(BANG)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_27() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_190() { + if (jj_scan_token(CONTINUE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_26() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_170() { + if (jj_scan_token(TILDE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_140() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_181() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_147() { + if (jj_scan_token(LONG)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_139() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_170()) { + jj_scanpos = xsp; + if (jj_3R_171()) { + jj_scanpos = xsp; + if (jj_3R_172()) { + jj_scanpos = xsp; + if (jj_3R_173()) { + jj_scanpos = xsp; + if (jj_3R_174()) { + jj_scanpos = xsp; + if (jj_3R_175()) { + jj_scanpos = xsp; + if (jj_3R_176()) { + jj_scanpos = xsp; + if (jj_3R_177()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_138() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_146() { + if (jj_scan_token(INT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_25() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_98()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_96() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_25()) { + jj_scanpos = xsp; + if (jj_3R_138()) { + jj_scanpos = xsp; + if (jj_3R_139()) { + jj_scanpos = xsp; + if (jj_3R_140()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_23() { + if (jj_3R_96()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_77() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_40() { + if (jj_3R_104()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_189() { + if (jj_scan_token(BREAK)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_165() { + if (jj_3R_194()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_24() { + if (jj_3R_97()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_164() { + if (jj_3R_193()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_145() { + if (jj_scan_token(SHORT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_163() { + if (jj_3R_192()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_137() { + if (jj_3R_169()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_168() { + if (jj_scan_token(BANG)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_150() { + if (jj_scan_token(VOID)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_167() { + if (jj_scan_token(TILDE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_162() { + if (jj_3R_191()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_10() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_76()) { + jj_scanpos = xsp; + if (jj_3R_77()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_75() { + if (jj_scan_token(SYNCHRONIZED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_76() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_161() { + if (jj_3R_190()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_144() { + if (jj_scan_token(BYTE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_95() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_136()) { + jj_scanpos = xsp; + if (jj_3R_137()) { + jj_scanpos = xsp; + if (jj_3_24()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_136() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_167()) { + jj_scanpos = xsp; + if (jj_3R_168()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_160() { + if (jj_3R_189()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_110() { + if (jj_3R_151()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_19() { + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_159() { + if (jj_3R_188()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_149() { + if (jj_scan_token(DOUBLE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_99() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_19()) { jj_scanpos = xsp; break; } + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } + return false; + } + + final private boolean jj_3R_158() { + if (jj_3R_187()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_74() { + if (jj_scan_token(NATIVE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_223() { + if (jj_scan_token(DECR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_143() { + if (jj_scan_token(CHAR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_222() { + if (jj_scan_token(INCR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_157() { + if (jj_3R_186()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_71() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_94() { + if (jj_scan_token(DECR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_68() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_231() { + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_156() { + if (jj_3R_185()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_206() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_222()) { + jj_scanpos = xsp; + if (jj_3R_223()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_148() { + if (jj_scan_token(FLOAT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_39() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(COLON)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_155() { + if (jj_3R_184()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_21() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_93()) { + jj_scanpos = xsp; + if (jj_3R_94()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_93() { + if (jj_scan_token(INCR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_154() { + if (jj_3R_183()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_142() { + if (jj_scan_token(BOOLEAN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_73() { + if (jj_scan_token(VOLATILE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_92() { + if (jj_scan_token(MINUS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_153() { + if (jj_3R_182()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_98() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_142()) { + jj_scanpos = xsp; + if (jj_3R_143()) { + jj_scanpos = xsp; + if (jj_3R_144()) { + jj_scanpos = xsp; + if (jj_3R_145()) { + jj_scanpos = xsp; + if (jj_3R_146()) { + jj_scanpos = xsp; + if (jj_3R_147()) { + jj_scanpos = xsp; + if (jj_3R_148()) { + jj_scanpos = xsp; + if (jj_3R_149()) { + jj_scanpos = xsp; + if (jj_3R_150()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_70() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_22() { + if (jj_3R_95()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_152() { + if (jj_3R_181()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_67() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_105() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_152()) { + jj_scanpos = xsp; + if (jj_3R_153()) { + jj_scanpos = xsp; + if (jj_3R_154()) { + jj_scanpos = xsp; + if (jj_3R_155()) { + jj_scanpos = xsp; + if (jj_3R_156()) { + jj_scanpos = xsp; + if (jj_3R_157()) { + jj_scanpos = xsp; + if (jj_3R_158()) { + jj_scanpos = xsp; + if (jj_3R_159()) { + jj_scanpos = xsp; + if (jj_3R_160()) { + jj_scanpos = xsp; + if (jj_3R_161()) { + jj_scanpos = xsp; + if (jj_3R_162()) { + jj_scanpos = xsp; + if (jj_3R_163()) { + jj_scanpos = xsp; + if (jj_3R_164()) { + jj_scanpos = xsp; + if (jj_3R_165()) { + jj_scanpos = xsp; + if (jj_3_40()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_20() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_91()) { + jj_scanpos = xsp; + if (jj_3R_92()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_91() { + if (jj_scan_token(PLUS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_240() { + if (jj_3R_206()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_242() { + if (jj_scan_token(MINUS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_241() { + if (jj_scan_token(PLUS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_230() { + if (jj_3R_98()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_72() { + if (jj_scan_token(TRANSIENT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_69() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_228() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_230()) { + jj_scanpos = xsp; + if (jj_3R_231()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_66() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_9() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_66()) { + jj_scanpos = xsp; + if (jj_3R_67()) { + jj_scanpos = xsp; + if (jj_3R_68()) { + jj_scanpos = xsp; + if (jj_3R_69()) { + jj_scanpos = xsp; + if (jj_3R_70()) { + jj_scanpos = xsp; + if (jj_3R_71()) { + jj_scanpos = xsp; + if (jj_3R_72()) { + jj_scanpos = xsp; + if (jj_3R_73()) { + jj_scanpos = xsp; + if (jj_3R_74()) { + jj_scanpos = xsp; + if (jj_3R_75()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_239() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_241()) { + jj_scanpos = xsp; + if (jj_3R_242()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_238() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_239()) { + jj_scanpos = xsp; + if (jj_3R_240()) { + jj_scanpos = xsp; + if (jj_3_22()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_51() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_38() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_37() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_237() { + if (jj_3R_238()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_50() { + if (jj_3R_110()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_188() { + if (jj_scan_token(FOR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_18() { + if (jj_scan_token(THIS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_236() { + if (jj_3R_237()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_116() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_115() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_90() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_35() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_49() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_235() { + if (jj_3R_236()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_114() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_36() { + if (jj_scan_token(NEW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_98()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_89() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_187() { + if (jj_scan_token(DO)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_227() { + if (jj_scan_token(NEW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_226() { + if (jj_scan_token(NEW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_219() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_226()) { + jj_scanpos = xsp; + if (jj_3R_227()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_112() { + if (jj_scan_token(METACLASS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_17() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_88()) { + jj_scanpos = xsp; + if (jj_3R_89()) { + jj_scanpos = xsp; + if (jj_3R_90()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_88() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_234() { + if (jj_3R_235()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_48() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_51() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_113()) { + jj_scanpos = xsp; + if (jj_3R_114()) { + jj_scanpos = xsp; + if (jj_3R_115()) { + jj_scanpos = xsp; + if (jj_3R_116()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_50() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_111()) { + jj_scanpos = xsp; + if (jj_3R_112()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_111() { + if (jj_scan_token(IDENTIFIER)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_113() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_8() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_127() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_2() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_51()) { jj_scanpos = xsp; break; } + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } + if (jj_scan_token(CLASS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_186() { + if (jj_scan_token(WHILE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_130() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_126() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_34() { + if (jj_3R_87()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_233() { + if (jj_3R_234()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_47() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_125() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_129() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_65() { + if (jj_scan_token(INTERFACE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_46() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_217() { + if (jj_scan_token(NULL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_232() { + if (jj_3R_233()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_216() { + if (jj_scan_token(FALSE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_61() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_64() { + if (jj_scan_token(CLASS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_128() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_215() { + if (jj_scan_token(TRUE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_185() { + if (jj_scan_token(IF)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_58() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_63() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_124()) { + jj_scanpos = xsp; + if (jj_3R_125()) { + jj_scanpos = xsp; + if (jj_3R_126()) { + jj_scanpos = xsp; + if (jj_3R_127()) { + jj_scanpos = xsp; + if (jj_3R_128()) { + jj_scanpos = xsp; + if (jj_3R_129()) { + jj_scanpos = xsp; + if (jj_3R_130()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_124() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_214() { + if (jj_scan_token(STRING_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_7() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_63()) { jj_scanpos = xsp; break; } + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } + xsp = jj_scanpos; + if (jj_3R_64()) { + jj_scanpos = xsp; + if (jj_3R_65()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_16() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_213() { + if (jj_scan_token(CHARACTER_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_62() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_6() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_62()) jj_scanpos = xsp; + else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(LBRACE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_212() { + if (jj_scan_token(DOUBLE_FLOATING_POINT_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_60() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_211() { + if (jj_scan_token(FLOATING_POINT_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_109() { + if (jj_scan_token(_DEFAULT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_57() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_229() { + if (jj_3R_232()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_210() { + if (jj_scan_token(LONG_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_209() { + if (jj_scan_token(INTEGER_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_198() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_209()) { + jj_scanpos = xsp; + if (jj_3R_210()) { + jj_scanpos = xsp; + if (jj_3R_211()) { + jj_scanpos = xsp; + if (jj_3R_212()) { + jj_scanpos = xsp; + if (jj_3R_213()) { + jj_scanpos = xsp; + if (jj_3R_214()) { + jj_scanpos = xsp; + if (jj_3R_215()) { + jj_scanpos = xsp; + if (jj_3R_216()) { + jj_scanpos = xsp; + if (jj_3R_217()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_107() { + if (jj_scan_token(_DEFAULT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_1() { + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_45() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_108()) { + jj_scanpos = xsp; + if (jj_3R_109()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_108() { + if (jj_scan_token(CASE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_59() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_56() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_5() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_56()) { + jj_scanpos = xsp; + if (jj_3R_57()) { + jj_scanpos = xsp; + if (jj_3R_58()) { + jj_scanpos = xsp; + if (jj_3R_59()) { + jj_scanpos = xsp; + if (jj_3R_60()) { + jj_scanpos = xsp; + if (jj_3R_61()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_120() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_44() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_106()) { + jj_scanpos = xsp; + if (jj_3R_107()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_106() { + if (jj_scan_token(CASE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_224() { + if (jj_3R_229()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_33() { + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_123() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_119() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_184() { + if (jj_scan_token(SWITCH)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_221() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_118() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_208() { + if (jj_3R_224()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_122() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_43() { + if (jj_3R_97()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_180() { + if (jj_3R_207()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_121() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_205() { + if (jj_3R_221()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_55() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_117()) { + jj_scanpos = xsp; + if (jj_3R_118()) { + jj_scanpos = xsp; + if (jj_3R_119()) { + jj_scanpos = xsp; + if (jj_3R_120()) { + jj_scanpos = xsp; + if (jj_3R_121()) { + jj_scanpos = xsp; + if (jj_3R_122()) { + jj_scanpos = xsp; + if (jj_3R_123()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_117() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_179() { + if (jj_3R_206()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_151() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_179()) { + jj_scanpos = xsp; + lookingAhead = true; + jj_semLA = AssignmentLookahead(); + lookingAhead = false; + if (!jj_semLA || jj_3R_180()) { + jj_scanpos = xsp; + if (jj_3_43()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_4() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_55()) { jj_scanpos = xsp; break; } + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } + if (jj_scan_token(CLASS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_204() { + if (jj_3R_220()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_103() { + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_195() { + if (jj_3R_208()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_32() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_103()) jj_scanpos = xsp; + else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(THIS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_203() { + if (jj_3R_219()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_202() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_104() { + if (jj_3R_151()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_201() { + if (jj_scan_token(SUPER)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_200() { + if (jj_3R_218()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_199() { + if (jj_3R_198()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_178() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_199()) { + jj_scanpos = xsp; + if (jj_3R_200()) { + jj_scanpos = xsp; + if (jj_3R_201()) { + jj_scanpos = xsp; + if (jj_3R_202()) { + jj_scanpos = xsp; + if (jj_3R_203()) { + jj_scanpos = xsp; + lookingAhead = true; + jj_semLA = ClassLiteralLookahead(); + lookingAhead = false; + if (!jj_semLA || jj_3R_204()) { + jj_scanpos = xsp; + if (jj_3R_205()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_183() { + if (jj_scan_token(SEMICOLON)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_166() { + if (jj_3R_195()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_134() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_42() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_102() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_15() { + if (jj_3R_87()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + public ParserTokenManager token_source; + JavaCharStream jj_input_stream; + public Token token, jj_nt; + private int jj_ntk; + private Token jj_scanpos, jj_lastpos; + private int jj_la; + public boolean lookingAhead = false; + private boolean jj_semLA; + private int jj_gen; + final private int[] jj_la1 = new int[85]; + final private int[] jj_la1_0 = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20002000,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20002000,0x0,0x82094000,0x82094000,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,0x10000000,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x82094000,0x1408000,0x100000,0x0,0x0,0x820000,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,}; + final private int[] jj_la1_1 = {0x0,0x1000,0x10,0x10,0x0,0x0,0x80000000,0x0,0x0,0x80000000,0x0,0x2224e200,0x0,0x8,0x0,0x0,0x0,0x80000000,0x1000000,0x0,0x0,0x0,0x0,0x0,0x2224e200,0x40000,0x90020140,0x10020140,0x0,0x0,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x84480c00,0x0,0x0,0x0,0x80000000,0x0,0x4000800,0x80400,0x80000000,0x4000800,0x0,0x0,0x0,0x400,0x90020140,0x48b10005,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x80000000,0x0,}; + final private int[] jj_la1_2 = {0x100000,0x0,0x0,0x0,0x400000,0x100000,0x800,0x200000,0x20100000,0x0,0x1,0x0,0x0,0x0,0x100000,0x100000,0x200000,0x800,0x0,0x110000,0x800000,0x10000,0x200000,0x200000,0x0,0x0,0x800,0x0,0x200000,0x200000,0x800,0x800000,0x800000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x83000000,0x83000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000000,0xc000000,0xc004ec6,0x4000,0x0,0x0,0x800,0x444000,0x6c6,0x4000,0x800,0x6c6,0x200000,0x10000,0x4000,0x0,0x800,0x110000,0x0,0x200000,0x0,0x0,0x10000,0x10000,0x0,0x10000,0x10000,0x10000,0x200000,0x200000,0x800,0x800,0x0,}; + final private int[] jj_la1_3 = {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,0xffe0000,0xffe0000,0x0,0x4,0x8,0x800,0x1000,0x400,0x2,0x2,0x0,0x1,0x1,0x1c000,0x1c000,0xc0,0xc0,0x2300,0x2300,0xc0,0x30,0x0,0x0,0x0,0x0,0x30,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + final private JJCalls[] jj_2_rtns = new JJCalls[52]; + private boolean jj_rescan = false; + private int jj_gc = 0; + + public Parser(java.io.InputStream stream) { + jj_input_stream = new JavaCharStream(stream, 1, 1); + token_source = new ParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public void ReInit(java.io.InputStream stream) { + jj_input_stream.ReInit(stream, 1, 1); + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public Parser(java.io.Reader stream) { + jj_input_stream = new JavaCharStream(stream, 1, 1); + token_source = new ParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public void ReInit(java.io.Reader stream) { + jj_input_stream.ReInit(stream, 1, 1); + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public Parser(ParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public void ReInit(ParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + final private Token jj_consume_token(int kind) throws ParseException { + Token oldToken; + if ((oldToken = token).next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + if (token.kind == kind) { + jj_gen++; + if (++jj_gc > 100) { + jj_gc = 0; + for (int i = 0; i < jj_2_rtns.length; i++) { + JJCalls c = jj_2_rtns[i]; + while (c != null) { + if (c.gen < jj_gen) c.first = null; + c = c.next; + } + } + } + return token; + } + token = oldToken; + jj_kind = kind; + throw generateParseException(); + } + + final private boolean jj_scan_token(int kind) { + if (jj_scanpos == jj_lastpos) { + jj_la--; + if (jj_scanpos.next == null) { + jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); + } else { + jj_lastpos = jj_scanpos = jj_scanpos.next; + } + } else { + jj_scanpos = jj_scanpos.next; + } + if (jj_rescan) { + int i = 0; Token tok = token; + while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } + if (tok != null) jj_add_error_token(kind, i); + } + return (jj_scanpos.kind != kind); + } + + final public Token getNextToken() { + if (token.next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + jj_gen++; + return token; + } + + final public Token getToken(int index) { + Token t = lookingAhead ? jj_scanpos : token; + for (int i = 0; i < index; i++) { + if (t.next != null) t = t.next; + else t = t.next = token_source.getNextToken(); + } + return t; + } + + final private int jj_ntk() { + if ((jj_nt=token.next) == null) + return (jj_ntk = (token.next=token_source.getNextToken()).kind); + else + return (jj_ntk = jj_nt.kind); + } + + private java.util.Vector jj_expentries = new java.util.Vector(); + private int[] jj_expentry; + private int jj_kind = -1; + private int[] jj_lasttokens = new int[100]; + private int jj_endpos; + + private void jj_add_error_token(int kind, int pos) { + if (pos >= 100) return; + if (pos == jj_endpos + 1) { + jj_lasttokens[jj_endpos++] = kind; + } else if (jj_endpos != 0) { + jj_expentry = new int[jj_endpos]; + for (int i = 0; i < jj_endpos; i++) { + jj_expentry[i] = jj_lasttokens[i]; + } + boolean exists = false; + for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) { + int[] oldentry = (int[])(enum.nextElement()); + if (oldentry.length == jj_expentry.length) { + exists = true; + for (int i = 0; i < jj_expentry.length; i++) { + if (oldentry[i] != jj_expentry[i]) { + exists = false; + break; + } + } + if (exists) break; + } + } + if (!exists) jj_expentries.addElement(jj_expentry); + if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; + } + } + + final public ParseException generateParseException() { + jj_expentries.removeAllElements(); + boolean[] la1tokens = new boolean[124]; + for (int i = 0; i < 124; i++) { + la1tokens[i] = false; + } + if (jj_kind >= 0) { + la1tokens[jj_kind] = true; + jj_kind = -1; + } + for (int i = 0; i < 85; i++) { + if (jj_la1[i] == jj_gen) { + for (int j = 0; j < 32; j++) { + if ((jj_la1_0[i] & (1<<j)) != 0) { + la1tokens[j] = true; + } + if ((jj_la1_1[i] & (1<<j)) != 0) { + la1tokens[32+j] = true; + } + if ((jj_la1_2[i] & (1<<j)) != 0) { + la1tokens[64+j] = true; + } + if ((jj_la1_3[i] & (1<<j)) != 0) { + la1tokens[96+j] = true; + } + } + } + } + for (int i = 0; i < 124; i++) { + if (la1tokens[i]) { + jj_expentry = new int[1]; + jj_expentry[0] = i; + jj_expentries.addElement(jj_expentry); + } + } + jj_endpos = 0; + jj_rescan_token(); + jj_add_error_token(0, 0); + int[][] exptokseq = new int[jj_expentries.size()][]; + for (int i = 0; i < jj_expentries.size(); i++) { + exptokseq[i] = (int[])jj_expentries.elementAt(i); + } + return new ParseException(token, exptokseq, tokenImage); + } + + final public void enable_tracing() { + } + + final public void disable_tracing() { + } + + final private void jj_rescan_token() { + jj_rescan = true; + for (int i = 0; i < 52; i++) { + JJCalls p = jj_2_rtns[i]; + do { + if (p.gen > jj_gen) { + jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; + switch (i) { + case 0: jj_3_1(); break; + case 1: jj_3_2(); break; + case 2: jj_3_3(); break; + case 3: jj_3_4(); break; + case 4: jj_3_5(); break; + case 5: jj_3_6(); break; + case 6: jj_3_7(); break; + case 7: jj_3_8(); break; + case 8: jj_3_9(); break; + case 9: jj_3_10(); break; + case 10: jj_3_11(); break; + case 11: jj_3_12(); break; + case 12: jj_3_13(); break; + case 13: jj_3_14(); break; + case 14: jj_3_15(); break; + case 15: jj_3_16(); break; + case 16: jj_3_17(); break; + case 17: jj_3_18(); break; + case 18: jj_3_19(); break; + case 19: jj_3_20(); break; + case 20: jj_3_21(); break; + case 21: jj_3_22(); break; + case 22: jj_3_23(); break; + case 23: jj_3_24(); break; + case 24: jj_3_25(); break; + case 25: jj_3_26(); break; + case 26: jj_3_27(); break; + case 27: jj_3_28(); break; + case 28: jj_3_29(); break; + case 29: jj_3_30(); break; + case 30: jj_3_31(); break; + case 31: jj_3_32(); break; + case 32: jj_3_33(); break; + case 33: jj_3_34(); break; + case 34: jj_3_35(); break; + case 35: jj_3_36(); break; + case 36: jj_3_37(); break; + case 37: jj_3_38(); break; + case 38: jj_3_39(); break; + case 39: jj_3_40(); break; + case 40: jj_3_41(); break; + case 41: jj_3_42(); break; + case 42: jj_3_43(); break; + case 43: jj_3_44(); break; + case 44: jj_3_45(); break; + case 45: jj_3_46(); break; + case 46: jj_3_47(); break; + case 47: jj_3_48(); break; + case 48: jj_3_49(); break; + case 49: jj_3_50(); break; + case 50: jj_3_51(); break; + case 51: jj_3_52(); break; + } + } + p = p.next; + } while (p != null); + } + jj_rescan = false; + } + + final private void jj_save(int index, int xla) { + JJCalls p = jj_2_rtns[index]; + while (p.gen > jj_gen) { + if (p.next == null) { p = p.next = new JJCalls(); break; } + p = p.next; + } + p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; + } + + static final class JJCalls { + int gen; + Token first; + int arg; + JJCalls next; + } + +} + +class IntAndObj +{ + IntAndObj( int ptr, Object obj ) { + super(); this.ptr = ptr; this.obj = obj; + } + int ptr; + Object obj; +} |