| /* GeneratedJavaParser.java */ |
| /* Generated By:JavaCC: Do not edit this line. GeneratedJavaParser.java */ |
| /* |
| * Copyright (C) 2007-2010 JĂșlio Vilmar Gesser. |
| * Copyright (C) 2011, 2013-2016 The JavaParser Team. |
| * |
| * This file is part of JavaParser. |
| * |
| * JavaParser can be used either under the terms of |
| * a) the GNU Lesser General Public License as published by |
| * the Free Software Foundation, either version 3 of the License, or |
| * (at your option) any later version. |
| * b) the terms of the Apache License |
| * |
| * You should have received a copy of both licenses in LICENCE.LGPL and |
| * LICENCE.APACHE. Please refer to those files for details. |
| * |
| * JavaParser is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU Lesser General Public License for more details. |
| */ |
| package com.github.javaparser; |
| import java.io.*; |
| import java.util.*; |
| import com.github.javaparser.ast.*; |
| import com.github.javaparser.ast.body.*; |
| import com.github.javaparser.ast.comments.*; |
| import com.github.javaparser.ast.modules.*; |
| import com.github.javaparser.ast.expr.*; |
| import com.github.javaparser.ast.stmt.*; |
| import com.github.javaparser.ast.type.*; |
| import com.github.javaparser.utils.*; |
| import javax.annotation.Generated; |
| import static com.github.javaparser.JavaToken.INVALID; |
| import static com.github.javaparser.ast.Node.Parsedness.UNPARSABLE; |
| import static com.github.javaparser.utils.Utils.*; |
| import static com.github.javaparser.ast.NodeList.*; |
| import static com.github.javaparser.GeneratedJavaParser.*; |
| import static com.github.javaparser.Range.*; |
| import static com.github.javaparser.Position.*; |
| import static com.github.javaparser.ast.type.ArrayType.*; |
| import static com.github.javaparser.GeneratedJavaParserTokenManagerBase.*; |
| |
| @Generated("JavaCC") |
| final class GeneratedJavaParser extends GeneratedJavaParserBase implements GeneratedJavaParserConstants { |
| /* Returns the JavaParser specific token type of the last matched token */ |
| JavaToken token() { |
| return token.javaToken; |
| } |
| |
| /* Changes the amount by which the horizontal position is increased when a tab character is encountered. |
| One by default.*/ |
| void setTabSize(int size) { |
| jj_input_stream.setTabSize(size); |
| } |
| |
| @Override |
| GeneratedJavaParserTokenManager getTokenSource() { |
| return token_source; |
| } |
| |
| /***************************************** |
| * THE JAVA LANGUAGE GRAMMAR STARTS HERE * |
| *****************************************/ |
| |
| /* |
| * Program structuring syntax follows. |
| */ |
| final public |
| CompilationUnit CompilationUnit() throws ParseException {PackageDeclaration pakage = null; |
| NodeList<ImportDeclaration> imports = emptyList(); |
| ImportDeclaration in = null; |
| NodeList<TypeDeclaration<?>> types = emptyList(); |
| ModifierHolder modifier; |
| TypeDeclaration tn = null; |
| ModuleDeclaration module = null; |
| try { |
| label_1: |
| while (true) { |
| if (jj_2_1(2)) { |
| ; |
| } else { |
| break label_1; |
| } |
| jj_consume_token(SEMICOLON); |
| } |
| if (jj_2_2(2147483647)) { |
| pakage = PackageDeclaration(); |
| } else { |
| ; |
| } |
| label_2: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case CLASS: |
| case _DEFAULT: |
| case ENUM: |
| case FINAL: |
| case IMPORT: |
| case INTERFACE: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOLATILE: |
| case OPEN: |
| case MODULE: |
| case TRANSITIVE: |
| case SEMICOLON: |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[0] = jj_gen; |
| break label_2; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IMPORT:{ |
| in = ImportDeclaration(); |
| imports = add(imports, in); |
| break; |
| } |
| case ABSTRACT: |
| case CLASS: |
| case _DEFAULT: |
| case ENUM: |
| case FINAL: |
| case INTERFACE: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOLATILE: |
| case OPEN: |
| case MODULE: |
| case TRANSITIVE: |
| case SEMICOLON: |
| case AT:{ |
| modifier = Modifiers(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CLASS: |
| case INTERFACE:{ |
| tn = ClassOrInterfaceDeclaration(modifier); |
| types = add(types, tn); |
| break; |
| } |
| case ENUM:{ |
| tn = EnumDeclaration(modifier); |
| types = add(types, tn); |
| break; |
| } |
| case AT:{ |
| tn = AnnotationTypeDeclaration(modifier); |
| types = add(types, tn); |
| break; |
| } |
| case OPEN: |
| case MODULE:{ |
| module = ModuleDeclaration(modifier); |
| break; |
| } |
| case SEMICOLON:{ |
| jj_consume_token(SEMICOLON); |
| break; |
| } |
| default: |
| jj_la1[1] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| } |
| default: |
| jj_la1[2] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case 0:{ |
| jj_consume_token(0); |
| break; |
| } |
| case CTRL_Z:{ |
| jj_consume_token(CTRL_Z); |
| break; |
| } |
| default: |
| jj_la1[3] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return new CompilationUnit(range(token_source.getHomeToken(), token()), pakage, imports, types, module); |
| } catch (ParseException e) { |
| recover(EOF, e); |
| final CompilationUnit compilationUnit = new CompilationUnit(range(token_source.getHomeToken(), token()), null, new NodeList<ImportDeclaration>(), new NodeList<TypeDeclaration<?>>(), null); |
| compilationUnit.setParsed(UNPARSABLE); |
| return compilationUnit; |
| } |
| } |
| |
| final public PackageDeclaration PackageDeclaration() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>(); |
| Name name; |
| JavaToken begin; |
| annotations = Annotations(); |
| jj_consume_token(PACKAGE); |
| begin = token(); |
| name = Name(); |
| jj_consume_token(SEMICOLON); |
| return new PackageDeclaration(range(begin, token()), annotations, name); |
| } |
| |
| final public ImportDeclaration ImportDeclaration() throws ParseException {Name name; |
| boolean isStatic = false; |
| boolean isAsterisk = false; |
| JavaToken begin; |
| jj_consume_token(IMPORT); |
| begin = token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case STATIC:{ |
| jj_consume_token(STATIC); |
| isStatic = true; |
| break; |
| } |
| default: |
| jj_la1[4] = jj_gen; |
| ; |
| } |
| name = Name(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case DOT:{ |
| jj_consume_token(DOT); |
| jj_consume_token(STAR); |
| isAsterisk = true; |
| break; |
| } |
| default: |
| jj_la1[5] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| return new ImportDeclaration(range(begin, token()), name, isStatic, isAsterisk); |
| } |
| |
| /* |
| * Modifiers. We match all modifiers in a single rule to reduce the chances of |
| * syntax errors for simple modifier mistakes. It will also enable us to give |
| * better error messages. |
| */ |
| final public |
| ModifierHolder Modifiers() throws ParseException {JavaToken begin = INVALID; |
| EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class); |
| NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>(); |
| AnnotationExpr ann; |
| label_3: |
| while (true) { |
| if (jj_2_3(2)) { |
| ; |
| } else { |
| break label_3; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case PUBLIC:{ |
| jj_consume_token(PUBLIC); |
| addModifier(modifiers, Modifier.PUBLIC); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case STATIC:{ |
| jj_consume_token(STATIC); |
| addModifier(modifiers, Modifier.STATIC); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case PROTECTED:{ |
| jj_consume_token(PROTECTED); |
| addModifier(modifiers, Modifier.PROTECTED); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case PRIVATE:{ |
| jj_consume_token(PRIVATE); |
| addModifier(modifiers, Modifier.PRIVATE); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case FINAL:{ |
| jj_consume_token(FINAL); |
| addModifier(modifiers, Modifier.FINAL); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case ABSTRACT:{ |
| jj_consume_token(ABSTRACT); |
| addModifier(modifiers, Modifier.ABSTRACT); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case SYNCHRONIZED:{ |
| jj_consume_token(SYNCHRONIZED); |
| addModifier(modifiers, Modifier.SYNCHRONIZED); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case NATIVE:{ |
| jj_consume_token(NATIVE); |
| addModifier(modifiers, Modifier.NATIVE); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case TRANSIENT:{ |
| jj_consume_token(TRANSIENT); |
| addModifier(modifiers, Modifier.TRANSIENT); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case VOLATILE:{ |
| jj_consume_token(VOLATILE); |
| addModifier(modifiers, Modifier.VOLATILE); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case STRICTFP:{ |
| jj_consume_token(STRICTFP); |
| addModifier(modifiers, Modifier.STRICTFP); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case TRANSITIVE:{ |
| jj_consume_token(TRANSITIVE); |
| addModifier(modifiers, Modifier.TRANSITIVE); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case _DEFAULT:{ |
| jj_consume_token(_DEFAULT); |
| addModifier(modifiers, Modifier.DEFAULT); begin = orIfInvalid(begin, token()); |
| break; |
| } |
| case AT:{ |
| ann = Annotation(); |
| annotations = add(annotations, ann); begin = orIfInvalid(begin, ann); |
| break; |
| } |
| default: |
| jj_la1[6] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return new ModifierHolder(begin, modifiers, annotations); |
| } |
| |
| /* |
| * Declaration syntax follows. |
| */ |
| final public |
| ClassOrInterfaceDeclaration ClassOrInterfaceDeclaration(ModifierHolder modifier) throws ParseException {boolean isInterface = false; |
| SimpleName name; |
| RangedList<TypeParameter> typePar = new RangedList<TypeParameter>(emptyList()); |
| NodeList<ClassOrInterfaceType> extList = emptyList(); |
| NodeList<ClassOrInterfaceType> impList = emptyList(); |
| NodeList<BodyDeclaration<?>> members = emptyList(); |
| JavaToken begin = modifier.begin; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CLASS:{ |
| jj_consume_token(CLASS); |
| break; |
| } |
| case INTERFACE:{ |
| jj_consume_token(INTERFACE); |
| isInterface = true; |
| break; |
| } |
| default: |
| jj_la1[7] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| begin = orIfInvalid(begin, token()); |
| name = SimpleName(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typePar = TypeParameters(); |
| break; |
| } |
| default: |
| jj_la1[8] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case EXTENDS:{ |
| extList = ExtendsList(); |
| break; |
| } |
| default: |
| jj_la1[9] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IMPLEMENTS:{ |
| impList = ImplementsList(); |
| break; |
| } |
| default: |
| jj_la1[10] = jj_gen; |
| ; |
| } |
| members = ClassOrInterfaceBody(); |
| return new ClassOrInterfaceDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, isInterface, name, typePar.list, extList, impList, members); |
| } |
| |
| final public NodeList<ClassOrInterfaceType> ExtendsList() throws ParseException {boolean extendsMoreThanOne = false; |
| NodeList<ClassOrInterfaceType> ret = new NodeList<ClassOrInterfaceType>(); |
| ClassOrInterfaceType cit; |
| jj_consume_token(EXTENDS); |
| cit = AnnotatedClassOrInterfaceType(); |
| ret.add(cit); |
| label_4: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[11] = jj_gen; |
| break label_4; |
| } |
| jj_consume_token(COMMA); |
| cit = AnnotatedClassOrInterfaceType(); |
| ret.add(cit); extendsMoreThanOne = true; |
| } |
| return ret; |
| } |
| |
| final public NodeList<ClassOrInterfaceType> ImplementsList() throws ParseException {NodeList<ClassOrInterfaceType> ret = new NodeList<ClassOrInterfaceType>(); |
| ClassOrInterfaceType cit; |
| jj_consume_token(IMPLEMENTS); |
| cit = AnnotatedClassOrInterfaceType(); |
| ret.add(cit); |
| label_5: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[12] = jj_gen; |
| break label_5; |
| } |
| jj_consume_token(COMMA); |
| cit = AnnotatedClassOrInterfaceType(); |
| ret.add(cit); |
| } |
| return ret; |
| } |
| |
| final public EnumDeclaration EnumDeclaration(ModifierHolder modifier) throws ParseException {SimpleName name; |
| NodeList<ClassOrInterfaceType> impList = emptyList(); |
| EnumConstantDeclaration entry; |
| NodeList<EnumConstantDeclaration> entries = emptyList(); |
| BodyDeclaration<?> member; |
| NodeList<BodyDeclaration<?>> members = emptyList(); |
| JavaToken begin = modifier.begin; |
| jj_consume_token(ENUM); |
| begin = orIfInvalid(begin, token()); |
| name = SimpleName(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IMPLEMENTS:{ |
| impList = ImplementsList(); |
| break; |
| } |
| default: |
| jj_la1[13] = jj_gen; |
| ; |
| } |
| jj_consume_token(LBRACE); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ENUM: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case AT:{ |
| entry = EnumConstantDeclaration(); |
| entries.add(entry); |
| label_6: |
| while (true) { |
| if (jj_2_4(2)) { |
| ; |
| } else { |
| break label_6; |
| } |
| jj_consume_token(COMMA); |
| entry = EnumConstantDeclaration(); |
| entries.add(entry); |
| } |
| break; |
| } |
| default: |
| jj_la1[14] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| jj_consume_token(COMMA); |
| break; |
| } |
| default: |
| jj_la1[15] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case SEMICOLON:{ |
| jj_consume_token(SEMICOLON); |
| label_7: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case CLASS: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case INTERFACE: |
| case LONG: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOID: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case LBRACE: |
| case SEMICOLON: |
| case AT: |
| case LT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[16] = jj_gen; |
| break label_7; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case CLASS: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case INTERFACE: |
| case LONG: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOID: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case LBRACE: |
| case AT: |
| case LT:{ |
| member = ClassOrInterfaceBodyDeclaration(); |
| members = add(members, member); |
| break; |
| } |
| case SEMICOLON:{ |
| jj_consume_token(SEMICOLON); |
| break; |
| } |
| default: |
| jj_la1[17] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| break; |
| } |
| default: |
| jj_la1[18] = jj_gen; |
| ; |
| } |
| jj_consume_token(RBRACE); |
| return new EnumDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, name, impList, entries, members); |
| } |
| |
| final public EnumConstantDeclaration EnumConstantDeclaration() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>(); |
| AnnotationExpr ann; |
| SimpleName name; |
| NodeList<Expression> args = emptyList(); |
| NodeList<BodyDeclaration<?>> classBody = emptyList(); |
| JavaToken begin = INVALID; |
| |
| label_8: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[19] = jj_gen; |
| break label_8; |
| } |
| ann = Annotation(); |
| annotations = add(annotations, ann); begin = orIfInvalid(begin, ann); |
| } |
| name = SimpleName(); |
| begin = orIfInvalid(begin, token()); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LPAREN:{ |
| args = Arguments(); |
| break; |
| } |
| default: |
| jj_la1[20] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACE:{ |
| classBody = ClassOrInterfaceBody(); |
| break; |
| } |
| default: |
| jj_la1[21] = jj_gen; |
| ; |
| } |
| return new EnumConstantDeclaration(range(begin, token()), annotations, name, args, classBody); |
| } |
| |
| /** |
| * If the list inside the returned RangedList is null, there are no brackets. |
| * If it is empty, there are brackets, but nothing is in them <>. |
| * The normal case is that it contains TypeParameters, like <A, B, C>. |
| */ |
| final public RangedList<TypeParameter> TypeParameters() throws ParseException {RangedList<TypeParameter> ret = new RangedList<TypeParameter>(new NodeList<TypeParameter>()); |
| TypeParameter tp; |
| NodeList<AnnotationExpr> annotations; |
| jj_consume_token(LT); |
| ret.beginAt(token()); |
| annotations = Annotations(); |
| tp = TypeParameter(annotations); |
| ret.add(tp); annotations = null; |
| label_9: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[22] = jj_gen; |
| break label_9; |
| } |
| jj_consume_token(COMMA); |
| annotations = Annotations(); |
| tp = TypeParameter(annotations); |
| ret.add(tp); annotations = null; |
| } |
| jj_consume_token(GT); |
| ret.endAt(token()); |
| return ret; |
| } |
| |
| final public TypeParameter TypeParameter(NodeList<AnnotationExpr> annotations) throws ParseException {SimpleName name; |
| NodeList<ClassOrInterfaceType> typeBound = emptyList(); |
| JavaToken begin; |
| name = SimpleName(); |
| begin=token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case EXTENDS:{ |
| typeBound = TypeBound(); |
| break; |
| } |
| default: |
| jj_la1[23] = jj_gen; |
| ; |
| } |
| return new TypeParameter(range(begin, token()), name, typeBound, annotations); |
| } |
| |
| final public NodeList<ClassOrInterfaceType> TypeBound() throws ParseException {NodeList<ClassOrInterfaceType> ret = emptyList(); |
| ClassOrInterfaceType cit; |
| jj_consume_token(EXTENDS); |
| cit = AnnotatedClassOrInterfaceType(); |
| ret.add(cit); |
| label_10: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BIT_AND:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[24] = jj_gen; |
| break label_10; |
| } |
| jj_consume_token(BIT_AND); |
| cit = AnnotatedClassOrInterfaceType(); |
| ret.add(cit); |
| } |
| return ret; |
| } |
| |
| final public NodeList<BodyDeclaration<?>> ClassOrInterfaceBody() throws ParseException {NodeList<BodyDeclaration<?>> ret = emptyList(); |
| BodyDeclaration member; |
| jj_consume_token(LBRACE); |
| label_11: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case CLASS: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case INTERFACE: |
| case LONG: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOID: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case LBRACE: |
| case SEMICOLON: |
| case AT: |
| case LT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[25] = jj_gen; |
| break label_11; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case CLASS: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case INTERFACE: |
| case LONG: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOID: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case LBRACE: |
| case AT: |
| case LT:{ |
| member = ClassOrInterfaceBodyDeclaration(); |
| ret.add(member); |
| break; |
| } |
| case SEMICOLON:{ |
| jj_consume_token(SEMICOLON); |
| break; |
| } |
| default: |
| jj_la1[26] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| jj_consume_token(RBRACE); |
| return ret; |
| } |
| |
| final public BodyDeclaration<?> ClassOrInterfaceBodyDeclaration() throws ParseException {ModifierHolder modifier; |
| BodyDeclaration<?> ret; |
| if (jj_2_9(2)) { |
| ret = InitializerDeclaration(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case CLASS: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case INTERFACE: |
| case LONG: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOID: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case AT: |
| case LT:{ |
| // Just get all the modifiers out of the way. If you want to do |
| // more checks, pass the modifiers down to the member |
| modifier = Modifiers(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CLASS: |
| case INTERFACE:{ |
| ret = ClassOrInterfaceDeclaration(modifier); |
| break; |
| } |
| default: |
| jj_la1[27] = jj_gen; |
| if (jj_2_5(2147483647)) { |
| ret = EnumDeclaration(modifier); |
| } else if (jj_2_6(2147483647)) { |
| ret = AnnotationTypeDeclaration(modifier); |
| } else if (jj_2_7(2147483647)) { |
| ret = ConstructorDeclaration(modifier); |
| } else if (jj_2_8(2147483647)) { |
| ret = FieldDeclaration(modifier); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| case STRICTFP: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case AT: |
| case LT:{ |
| ret = MethodDeclaration(modifier); |
| break; |
| } |
| default: |
| jj_la1[28] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| break; |
| } |
| default: |
| jj_la1[29] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public FieldDeclaration FieldDeclaration(ModifierHolder modifier) throws ParseException {Type partialType; |
| NodeList<VariableDeclarator> variables = new NodeList<VariableDeclarator>(); |
| VariableDeclarator val; |
| // Modifiers are already matched in the caller |
| partialType = Type(emptyList()); |
| val = VariableDeclarator(partialType); |
| variables.add(val); |
| label_12: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[30] = jj_gen; |
| break label_12; |
| } |
| jj_consume_token(COMMA); |
| val = VariableDeclarator(partialType); |
| variables.add(val); |
| } |
| jj_consume_token(SEMICOLON); |
| JavaToken begin = orIfInvalid(modifier.begin, partialType); |
| return new FieldDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, variables); |
| } |
| |
| final public VariableDeclarator VariableDeclarator(Type partialType) throws ParseException {Pair<SimpleName, List<ArrayBracketPair>> id; |
| Expression init = null; |
| id = VariableDeclaratorId(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ASSIGN:{ |
| jj_consume_token(ASSIGN); |
| init = VariableInitializer(); |
| break; |
| } |
| default: |
| jj_la1[31] = jj_gen; |
| ; |
| } |
| return new VariableDeclarator(range(id.a, token()), juggleArrayType(partialType, id.b), id.a, init); |
| } |
| |
| final public Pair<SimpleName, List<ArrayBracketPair>> VariableDeclaratorId() throws ParseException {SimpleName name; |
| JavaToken begin; |
| ArrayBracketPair arrayBracketPair; |
| List<ArrayBracketPair> arrayBracketPairs = new ArrayList(0); |
| name = SimpleName(); |
| begin=token(); |
| label_13: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACKET: |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[32] = jj_gen; |
| break label_13; |
| } |
| arrayBracketPair = ArrayBracketPair(Origin.NAME); |
| arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); |
| } |
| if(storeTokens) { |
| name.setTokenRange(name.getTokenRange().get().withEnd(token())); |
| } |
| return new Pair(name, arrayBracketPairs); |
| } |
| |
| final public Expression VariableInitializer() throws ParseException {Expression ret; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACE:{ |
| ret = ArrayInitializer(); |
| break; |
| } |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| ret = Expression(); |
| break; |
| } |
| default: |
| jj_la1[33] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public ArrayInitializerExpr ArrayInitializer() throws ParseException {NodeList<Expression> values = emptyList(); |
| Expression val; |
| JavaToken begin; |
| jj_consume_token(LBRACE); |
| begin=token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case LBRACE: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| val = VariableInitializer(); |
| values = add(values, val); |
| label_14: |
| while (true) { |
| if (jj_2_10(2)) { |
| ; |
| } else { |
| break label_14; |
| } |
| jj_consume_token(COMMA); |
| val = VariableInitializer(); |
| values = add(values, val); |
| } |
| break; |
| } |
| default: |
| jj_la1[34] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| jj_consume_token(COMMA); |
| break; |
| } |
| default: |
| jj_la1[35] = jj_gen; |
| ; |
| } |
| jj_consume_token(RBRACE); |
| return new ArrayInitializerExpr(range(begin, token()), values); |
| } |
| |
| final public MethodDeclaration MethodDeclaration(ModifierHolder modifier) throws ParseException {RangedList<TypeParameter> typeParameters = new RangedList<TypeParameter>(emptyList()); |
| Type type; |
| SimpleName name; |
| Pair<NodeList<Parameter>, ReceiverParameter> parameters = new Pair<NodeList<Parameter>, ReceiverParameter>(emptyList(), null); |
| ArrayBracketPair arrayBracketPair; |
| List<ArrayBracketPair> arrayBracketPairs = new ArrayList(0); |
| NodeList<ReferenceType> throws_ = emptyList(); |
| BlockStmt body = null; |
| NodeList<AnnotationExpr> annotations; |
| JavaToken begin = modifier.begin; |
| ReferenceType throwType; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeParameters = TypeParameters(); |
| begin = orIfInvalid(begin, typeParameters.range.getBegin()); |
| break; |
| } |
| default: |
| jj_la1[36] = jj_gen; |
| ; |
| } |
| annotations = Annotations(); |
| modifier.annotations.addAll(annotations); begin = orIfInvalid(begin, nodeListBegin(annotations)); |
| type = ResultType(emptyList()); |
| begin = orIfInvalid(begin, type); |
| name = SimpleName(); |
| parameters = Parameters(); |
| label_15: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACKET: |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[37] = jj_gen; |
| break label_15; |
| } |
| arrayBracketPair = ArrayBracketPair(Origin.NAME); |
| arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case THROWS:{ |
| jj_consume_token(THROWS); |
| throwType = AnnotatedReferenceType(); |
| throws_ = add(throws_, throwType); |
| label_16: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[38] = jj_gen; |
| break label_16; |
| } |
| jj_consume_token(COMMA); |
| throwType = AnnotatedReferenceType(); |
| throws_ = add(throws_, throwType); |
| } |
| break; |
| } |
| default: |
| jj_la1[39] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACE:{ |
| body = Block(); |
| break; |
| } |
| case SEMICOLON:{ |
| jj_consume_token(SEMICOLON); |
| break; |
| } |
| default: |
| jj_la1[40] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| type = juggleArrayType(type, arrayBracketPairs); |
| return new MethodDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, typeParameters.list, type, name, parameters.a, throws_, body, parameters.b); |
| } |
| |
| final public ReferenceType AnnotatedReferenceType() throws ParseException {NodeList<AnnotationExpr> annotations; |
| ReferenceType type; |
| annotations = Annotations(); |
| type = ReferenceType(annotations); |
| return type; |
| } |
| |
| final public Type AnnotatedType() throws ParseException {NodeList<AnnotationExpr> annotations; |
| Type type; |
| annotations = Annotations(); |
| type = Type(annotations); |
| return type; |
| } |
| |
| final public Pair<NodeList<Parameter>, ReceiverParameter> Parameters() throws ParseException {NodeList<Parameter> ret = emptyList(); |
| Parameter par; |
| ReceiverParameter rp = null; |
| jj_consume_token(LPAREN); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case AT:{ |
| if (jj_2_11(2147483647)) { |
| rp = ReceiverParameter(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case AT:{ |
| par = Parameter(); |
| ret = add(ret, par); |
| break; |
| } |
| default: |
| jj_la1[41] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| label_17: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[42] = jj_gen; |
| break label_17; |
| } |
| jj_consume_token(COMMA); |
| par = Parameter(); |
| ret = add(ret, par); |
| } |
| break; |
| } |
| default: |
| jj_la1[43] = jj_gen; |
| ; |
| } |
| jj_consume_token(RPAREN); |
| return new Pair(ret, rp); |
| } |
| |
| final public NodeList<Parameter> LambdaParameters() throws ParseException {NodeList<Parameter> ret = null; |
| Parameter par; |
| par = Parameter(); |
| ret = add(ret, par); |
| label_18: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[44] = jj_gen; |
| break label_18; |
| } |
| jj_consume_token(COMMA); |
| par = Parameter(); |
| ret = add(ret, par); |
| } |
| return ret; |
| } |
| |
| final public NodeList<Parameter> InferredLambdaParameters() throws ParseException {NodeList<Parameter> ret = null; |
| Pair<SimpleName, List<ArrayBracketPair>> id; |
| id = VariableDeclaratorId(); |
| ret = add(ret, new Parameter(range(id.a, id.a), EnumSet.noneOf(Modifier.class), emptyList(), new UnknownType(), false, emptyList(), id.a)); |
| label_19: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[45] = jj_gen; |
| break label_19; |
| } |
| jj_consume_token(COMMA); |
| id = VariableDeclaratorId(); |
| ret = add(ret, new Parameter(range(id.a, id.a), EnumSet.noneOf(Modifier.class), emptyList(), new UnknownType(), false, emptyList(), id.a)); |
| } |
| return ret; |
| } |
| |
| final public Parameter Parameter() throws ParseException {ModifierHolder modifier; |
| Type partialType; |
| boolean isVarArg = false; |
| Pair<SimpleName, List<ArrayBracketPair>> id; |
| NodeList<AnnotationExpr> varArgAnnotations = emptyList(); |
| modifier = Modifiers(); |
| partialType = Type(emptyList()); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case AT: |
| case ELLIPSIS:{ |
| varArgAnnotations = Annotations(); |
| jj_consume_token(ELLIPSIS); |
| isVarArg = true; |
| break; |
| } |
| default: |
| jj_la1[46] = jj_gen; |
| ; |
| } |
| id = VariableDeclaratorId(); |
| JavaToken begin = orIfInvalid(modifier.begin, partialType); |
| return new Parameter(range(begin, token()), modifier.modifiers, modifier.annotations, juggleArrayType(partialType, id.b), isVarArg, varArgAnnotations, id.a); |
| } |
| |
| final public ReceiverParameter ReceiverParameter() throws ParseException {Type partialType; |
| Name id; |
| NodeList<AnnotationExpr> annotations = emptyList(); |
| annotations = Annotations(); |
| partialType = Type(emptyList()); |
| id = ReceiverParameterId(); |
| return new ReceiverParameter(range(partialType, token()), annotations, partialType, id); |
| } |
| |
| final public Name ReceiverParameterId() throws ParseException {Name ret = null; |
| NodeList<AnnotationExpr> annotations; |
| if (jj_2_12(2147483647)) { |
| ret = Name(); |
| jj_consume_token(DOT); |
| } else { |
| ; |
| } |
| annotations = Annotations(); |
| jj_consume_token(THIS); |
| return new Name(tokenRange(), ret, token.image, annotations); |
| } |
| |
| final public ConstructorDeclaration ConstructorDeclaration(ModifierHolder modifier) throws ParseException {RangedList<TypeParameter> typeParameters = new RangedList<TypeParameter>(emptyList()); |
| SimpleName name; |
| Pair<NodeList<Parameter>, ReceiverParameter> parameters = new Pair<NodeList<Parameter>, ReceiverParameter>(emptyList(), null); |
| NodeList<ReferenceType> throws_ = emptyList(); |
| ExplicitConstructorInvocationStmt exConsInv = null; |
| NodeList<Statement> stmts = emptyList(); |
| JavaToken begin = modifier.begin; |
| JavaToken blockBegin = INVALID; |
| ReferenceType throwType; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeParameters = TypeParameters(); |
| begin = orIfInvalid(begin, typeParameters.range.getBegin()); |
| break; |
| } |
| default: |
| jj_la1[47] = jj_gen; |
| ; |
| } |
| // Modifiers matched in the caller |
| name = SimpleName(); |
| begin = orIfInvalid(begin, typeParameters.range.getBegin()); begin = orIfInvalid(begin, token()); |
| parameters = Parameters(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case THROWS:{ |
| jj_consume_token(THROWS); |
| throwType = AnnotatedReferenceType(); |
| throws_ = add(throws_, throwType); |
| label_20: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[48] = jj_gen; |
| break label_20; |
| } |
| jj_consume_token(COMMA); |
| throwType = AnnotatedReferenceType(); |
| throws_ = add(throws_, throwType); |
| } |
| break; |
| } |
| default: |
| jj_la1[49] = jj_gen; |
| ; |
| } |
| jj_consume_token(LBRACE); |
| blockBegin=token(); |
| if (jj_2_13(2147483647)) { |
| exConsInv = ExplicitConstructorInvocation(); |
| } else { |
| ; |
| } |
| stmts = Statements(); |
| jj_consume_token(RBRACE); |
| if (exConsInv != null) { |
| stmts = prepend(stmts, exConsInv); |
| } |
| return new ConstructorDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, typeParameters.list, name, parameters.a, throws_, new BlockStmt(range(blockBegin, token()), stmts), parameters.b); |
| } |
| |
| final public ExplicitConstructorInvocationStmt ExplicitConstructorInvocation() throws ParseException {boolean isThis = false; |
| NodeList<Expression> args; |
| Expression expr = null; |
| RangedList<Type> typeArgs = new RangedList<Type>(null); |
| JavaToken begin = INVALID; |
| if (jj_2_15(2147483647)) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| begin=typeArgs.range.getBegin(); |
| break; |
| } |
| default: |
| jj_la1[50] = jj_gen; |
| ; |
| } |
| jj_consume_token(THIS); |
| begin = orIfInvalid(begin, token()); isThis = true; |
| args = Arguments(); |
| jj_consume_token(SEMICOLON); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case LT:{ |
| if (jj_2_14(2147483647)) { |
| expr = PrimaryExpressionWithoutSuperSuffix(); |
| jj_consume_token(DOT); |
| begin = orIfInvalid(begin, expr); |
| } else { |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| begin = orIfInvalid(begin, typeArgs.range.getBegin()); |
| break; |
| } |
| default: |
| jj_la1[51] = jj_gen; |
| ; |
| } |
| jj_consume_token(SUPER); |
| begin = orIfInvalid(begin, token()); |
| args = Arguments(); |
| jj_consume_token(SEMICOLON); |
| break; |
| } |
| default: |
| jj_la1[52] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return new ExplicitConstructorInvocationStmt(range(begin, token()),typeArgs.list, isThis, expr, args); |
| } |
| |
| final public NodeList<Statement> Statements() throws ParseException {NodeList<Statement> ret = emptyList(); |
| Statement stmt; |
| label_21: |
| while (true) { |
| if (jj_2_16(2)) { |
| ; |
| } else { |
| break label_21; |
| } |
| stmt = BlockStatement(); |
| ret = add(ret, stmt); |
| } |
| return ret; |
| } |
| |
| final public InitializerDeclaration InitializerDeclaration() throws ParseException {BlockStmt body; |
| JavaToken begin = INVALID; |
| boolean isStatic = false; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case STATIC:{ |
| jj_consume_token(STATIC); |
| isStatic = true; begin=token(); |
| break; |
| } |
| default: |
| jj_la1[53] = jj_gen; |
| ; |
| } |
| body = Block(); |
| begin = orIfInvalid(begin, body); |
| return new InitializerDeclaration(range(begin, token()), isStatic, body); |
| } |
| |
| /* |
| * Type, name and expression syntax follows. |
| */ |
| final public |
| Type Type(NodeList<AnnotationExpr> annotations) throws ParseException {Type ret; |
| if (jj_2_17(2)) { |
| ret = ReferenceType(annotations); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT:{ |
| ret = PrimitiveType(annotations); |
| break; |
| } |
| default: |
| jj_la1[54] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public ReferenceType ReferenceType(NodeList<AnnotationExpr> annotations) throws ParseException {Type type; |
| ArrayBracketPair arrayBracketPair; |
| List<ArrayBracketPair> arrayBracketPairs = new ArrayList(0); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT:{ |
| type = PrimitiveType(annotations); |
| label_22: |
| while (true) { |
| arrayBracketPair = ArrayBracketPair(Origin.TYPE); |
| arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); |
| if (jj_2_18(2147483647)) { |
| ; |
| } else { |
| break label_22; |
| } |
| } |
| break; |
| } |
| case ENUM: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| type = ClassOrInterfaceType(annotations); |
| label_23: |
| while (true) { |
| if (jj_2_19(2147483647)) { |
| ; |
| } else { |
| break label_23; |
| } |
| arrayBracketPair = ArrayBracketPair(Origin.TYPE); |
| arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); |
| } |
| break; |
| } |
| default: |
| jj_la1[55] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return (ReferenceType)wrapInArrayTypes(type, arrayBracketPairs); |
| } |
| |
| final public ArrayBracketPair ArrayBracketPair(Origin origin) throws ParseException {NodeList<AnnotationExpr> annotations; |
| JavaToken begin = INVALID; |
| annotations = Annotations(); |
| jj_consume_token(LBRACKET); |
| begin = orIfInvalid(begin, token()); |
| jj_consume_token(RBRACKET); |
| return new ArrayBracketPair(range(begin, token()), origin, annotations); |
| } |
| |
| final public IntersectionType IntersectionType(NodeList<AnnotationExpr> annotations) throws ParseException {JavaToken begin = INVALID; |
| ReferenceType elementType; |
| NodeList<ReferenceType> elements = emptyList(); |
| elementType = ReferenceType(annotations); |
| begin = orIfInvalid(begin, elementType); elements = add(elements, elementType); |
| jj_consume_token(BIT_AND); |
| label_24: |
| while (true) { |
| elementType = AnnotatedReferenceType(); |
| elements = add(elements, elementType); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[56] = jj_gen; |
| break label_24; |
| } |
| } |
| return new IntersectionType(range(begin, token()), elements); |
| } |
| |
| final public ClassOrInterfaceType AnnotatedClassOrInterfaceType() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>(); |
| ClassOrInterfaceType cit; |
| annotations = Annotations(); |
| cit = ClassOrInterfaceType(annotations); |
| return cit; |
| } |
| |
| final public ClassOrInterfaceType ClassOrInterfaceType(NodeList<AnnotationExpr> firstAnnotations) throws ParseException {ClassOrInterfaceType ret; |
| SimpleName name; |
| RangedList<Type> typeArgs = new RangedList<Type>(null); |
| JavaToken begin; |
| NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>(); |
| name = SimpleName(); |
| begin=token(); |
| if (jj_2_20(2)) { |
| typeArgs = TypeArguments(); |
| } else { |
| ; |
| } |
| ret = new ClassOrInterfaceType(range(begin, token()), null, name, typeArgs.list, firstAnnotations); |
| typeArgs = new RangedList<Type>(null); |
| label_25: |
| while (true) { |
| if (jj_2_21(2)) { |
| ; |
| } else { |
| break label_25; |
| } |
| jj_consume_token(DOT); |
| annotations = Annotations(); |
| name = SimpleName(); |
| if (jj_2_22(2)) { |
| typeArgs = TypeArguments(); |
| } else { |
| ; |
| } |
| ret = new ClassOrInterfaceType(range(begin, token()), ret, name, typeArgs.list, annotations); |
| typeArgs = new RangedList<Type>(null); |
| } |
| return ret; |
| } |
| |
| final public RangedList<Type> TypeArguments() throws ParseException {RangedList<Type> ret = new RangedList<Type>(new NodeList<Type>()); |
| Type type; |
| jj_consume_token(LT); |
| ret.beginAt(token()); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case AT: |
| case HOOK:{ |
| type = TypeArgument(); |
| ret.add(type); |
| label_26: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[57] = jj_gen; |
| break label_26; |
| } |
| jj_consume_token(COMMA); |
| type = TypeArgument(); |
| ret.add(type); |
| } |
| break; |
| } |
| default: |
| jj_la1[58] = jj_gen; |
| ; |
| } |
| jj_consume_token(GT); |
| ret.endAt(token()); |
| return ret; |
| } |
| |
| final public Type TypeArgument() throws ParseException {Type ret; |
| NodeList<AnnotationExpr> annotations; |
| annotations = Annotations(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| ret = Type(annotations); |
| break; |
| } |
| case HOOK:{ |
| ret = Wildcard(annotations); |
| break; |
| } |
| default: |
| jj_la1[59] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public WildcardType Wildcard(NodeList<AnnotationExpr> firstAnnotations) throws ParseException {ReferenceType ext = null; |
| ReferenceType sup = null; |
| JavaToken begin; |
| NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>(); |
| jj_consume_token(HOOK); |
| begin=token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case EXTENDS: |
| case SUPER:{ |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case EXTENDS:{ |
| jj_consume_token(EXTENDS); |
| annotations = Annotations(); |
| ext = ReferenceType(annotations); |
| break; |
| } |
| case SUPER:{ |
| jj_consume_token(SUPER); |
| annotations = Annotations(); |
| sup = ReferenceType(annotations); |
| break; |
| } |
| default: |
| jj_la1[60] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| } |
| default: |
| jj_la1[61] = jj_gen; |
| ; |
| } |
| return new WildcardType(range(begin, token()), ext, sup, firstAnnotations); |
| } |
| |
| final public PrimitiveType PrimitiveType(NodeList<AnnotationExpr> annotations) throws ParseException {PrimitiveType ret; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN:{ |
| jj_consume_token(BOOLEAN); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.BOOLEAN, annotations); |
| break; |
| } |
| case CHAR:{ |
| jj_consume_token(CHAR); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.CHAR, annotations); |
| break; |
| } |
| case BYTE:{ |
| jj_consume_token(BYTE); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.BYTE, annotations); |
| break; |
| } |
| case SHORT:{ |
| jj_consume_token(SHORT); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.SHORT, annotations); |
| break; |
| } |
| case INT:{ |
| jj_consume_token(INT); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.INT, annotations); |
| break; |
| } |
| case LONG:{ |
| jj_consume_token(LONG); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.LONG, annotations); |
| break; |
| } |
| case FLOAT:{ |
| jj_consume_token(FLOAT); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.FLOAT, annotations); |
| break; |
| } |
| case DOUBLE:{ |
| jj_consume_token(DOUBLE); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.DOUBLE, annotations); |
| break; |
| } |
| default: |
| jj_la1[62] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Type ResultType(NodeList<AnnotationExpr> annotations) throws ParseException {Type ret; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case VOID:{ |
| jj_consume_token(VOID); |
| ret = new VoidType(tokenRange()); |
| break; |
| } |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| ret = Type(annotations); |
| break; |
| } |
| default: |
| jj_la1[63] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Name Name() throws ParseException {Name ret; |
| NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>(); |
| annotations = Annotations(); |
| Identifier(); |
| ret = new Name(tokenRange(), null, token.image, annotations); |
| label_27: |
| while (true) { |
| if (jj_2_23(2147483647)) { |
| ; |
| } else { |
| break label_27; |
| } |
| jj_consume_token(DOT); |
| annotations = Annotations(); |
| Identifier(); |
| ret = new Name(range(ret, token()), ret, token.image, annotations); |
| } |
| return ret; |
| } |
| |
| final public SimpleName SimpleName() throws ParseException {SimpleName ret; |
| Identifier(); |
| ret = new SimpleName(tokenRange(), token.image); |
| return ret; |
| } |
| |
| final public String Identifier() throws ParseException {String ret; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case MODULE:{ |
| jj_consume_token(MODULE); |
| break; |
| } |
| case REQUIRES:{ |
| jj_consume_token(REQUIRES); |
| break; |
| } |
| case TO:{ |
| jj_consume_token(TO); |
| break; |
| } |
| case WITH:{ |
| jj_consume_token(WITH); |
| break; |
| } |
| case OPEN:{ |
| jj_consume_token(OPEN); |
| break; |
| } |
| case OPENS:{ |
| jj_consume_token(OPENS); |
| break; |
| } |
| case USES:{ |
| jj_consume_token(USES); |
| break; |
| } |
| case EXPORTS:{ |
| jj_consume_token(EXPORTS); |
| break; |
| } |
| case PROVIDES:{ |
| jj_consume_token(PROVIDES); |
| break; |
| } |
| case TRANSITIVE:{ |
| jj_consume_token(TRANSITIVE); |
| break; |
| } |
| case ENUM:{ |
| jj_consume_token(ENUM); |
| break; |
| } |
| case STRICTFP:{ |
| jj_consume_token(STRICTFP); |
| break; |
| } |
| case IDENTIFIER:{ |
| jj_consume_token(IDENTIFIER); |
| break; |
| } |
| default: |
| jj_la1[64] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = token.image; setTokenKind(IDENTIFIER); |
| return ret; |
| } |
| |
| /* |
| * Expression syntax follows. |
| */ |
| final public |
| Expression Expression() throws ParseException {Expression ret; |
| AssignExpr.Operator op; |
| Expression value; |
| Statement lambdaBody = null; |
| RangedList<Type> typeArgs = new RangedList<Type>(null); |
| ret = ConditionalExpression(); |
| switch ((jj_ntk==-1)?jj_ntk_f():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: |
| case ARROW: |
| case DOUBLECOLON:{ |
| if (jj_2_24(2)) { |
| op = AssignmentOperator(); |
| value = Expression(); |
| ret = new AssignExpr(range(ret, token()), ret, value, op); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ARROW:{ |
| jj_consume_token(ARROW); |
| lambdaBody = LambdaBody(); |
| if (ret instanceof CastExpr) { |
| ret = generateLambda(ret, lambdaBody); |
| } else if (ret instanceof ConditionalExpr) { |
| ConditionalExpr ce = (ConditionalExpr) ret; |
| if(ce.getElseExpr() != null) { |
| ce.setElseExpr(generateLambda(ce.getElseExpr(), lambdaBody)); |
| } |
| } else { |
| ret = generateLambda(ret, lambdaBody); |
| } |
| break; |
| } |
| case DOUBLECOLON:{ |
| jj_consume_token(DOUBLECOLON); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| break; |
| } |
| default: |
| jj_la1[65] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ENUM: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| Identifier(); |
| break; |
| } |
| case NEW:{ |
| jj_consume_token(NEW); |
| break; |
| } |
| default: |
| jj_la1[66] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image); |
| break; |
| } |
| default: |
| jj_la1[67] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| break; |
| } |
| default: |
| jj_la1[68] = jj_gen; |
| ; |
| } |
| return ret; |
| } |
| |
| final public AssignExpr.Operator AssignmentOperator() throws ParseException {AssignExpr.Operator ret; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ASSIGN:{ |
| jj_consume_token(ASSIGN); |
| ret = AssignExpr.Operator.ASSIGN; |
| break; |
| } |
| case STARASSIGN:{ |
| jj_consume_token(STARASSIGN); |
| ret = AssignExpr.Operator.MULTIPLY; |
| break; |
| } |
| case SLASHASSIGN:{ |
| jj_consume_token(SLASHASSIGN); |
| ret = AssignExpr.Operator.DIVIDE; |
| break; |
| } |
| case REMASSIGN:{ |
| jj_consume_token(REMASSIGN); |
| ret = AssignExpr.Operator.REMAINDER; |
| break; |
| } |
| case PLUSASSIGN:{ |
| jj_consume_token(PLUSASSIGN); |
| ret = AssignExpr.Operator.PLUS; |
| break; |
| } |
| case MINUSASSIGN:{ |
| jj_consume_token(MINUSASSIGN); |
| ret = AssignExpr.Operator.MINUS; |
| break; |
| } |
| case LSHIFTASSIGN:{ |
| jj_consume_token(LSHIFTASSIGN); |
| ret = AssignExpr.Operator.LEFT_SHIFT; |
| break; |
| } |
| case RSIGNEDSHIFTASSIGN:{ |
| jj_consume_token(RSIGNEDSHIFTASSIGN); |
| ret = AssignExpr.Operator.SIGNED_RIGHT_SHIFT; |
| break; |
| } |
| case RUNSIGNEDSHIFTASSIGN:{ |
| jj_consume_token(RUNSIGNEDSHIFTASSIGN); |
| ret = AssignExpr.Operator.UNSIGNED_RIGHT_SHIFT; |
| break; |
| } |
| case ANDASSIGN:{ |
| jj_consume_token(ANDASSIGN); |
| ret = AssignExpr.Operator.BINARY_AND; |
| break; |
| } |
| case XORASSIGN:{ |
| jj_consume_token(XORASSIGN); |
| ret = AssignExpr.Operator.XOR; |
| break; |
| } |
| case ORASSIGN:{ |
| jj_consume_token(ORASSIGN); |
| ret = AssignExpr.Operator.BINARY_OR; |
| break; |
| } |
| default: |
| jj_la1[69] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Expression ConditionalExpression() throws ParseException {Expression ret; |
| Expression left; |
| Expression right; |
| ret = ConditionalOrExpression(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case HOOK:{ |
| jj_consume_token(HOOK); |
| left = Expression(); |
| jj_consume_token(COLON); |
| right = ConditionalExpression(); |
| ret = new ConditionalExpr(range(ret, token()), ret, left, right); |
| break; |
| } |
| default: |
| jj_la1[70] = jj_gen; |
| ; |
| } |
| return ret; |
| } |
| |
| final public Expression ConditionalOrExpression() throws ParseException {Expression ret; |
| Expression right; |
| ret = ConditionalAndExpression(); |
| label_28: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case SC_OR:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[71] = jj_gen; |
| break label_28; |
| } |
| jj_consume_token(SC_OR); |
| right = ConditionalAndExpression(); |
| ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.OR); |
| } |
| return ret; |
| } |
| |
| final public Expression ConditionalAndExpression() throws ParseException {Expression ret; |
| Expression right; |
| ret = InclusiveOrExpression(); |
| label_29: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case SC_AND:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[72] = jj_gen; |
| break label_29; |
| } |
| jj_consume_token(SC_AND); |
| right = InclusiveOrExpression(); |
| ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.AND); |
| } |
| return ret; |
| } |
| |
| final public Expression InclusiveOrExpression() throws ParseException {Expression ret; |
| Expression right; |
| ret = ExclusiveOrExpression(); |
| label_30: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BIT_OR:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[73] = jj_gen; |
| break label_30; |
| } |
| jj_consume_token(BIT_OR); |
| right = ExclusiveOrExpression(); |
| ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.BINARY_OR); |
| } |
| return ret; |
| } |
| |
| final public Expression ExclusiveOrExpression() throws ParseException {Expression ret; |
| Expression right; |
| ret = AndExpression(); |
| label_31: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case XOR:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[74] = jj_gen; |
| break label_31; |
| } |
| jj_consume_token(XOR); |
| right = AndExpression(); |
| ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.XOR); |
| } |
| return ret; |
| } |
| |
| final public Expression AndExpression() throws ParseException {Expression ret; |
| Expression right; |
| ret = EqualityExpression(); |
| label_32: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BIT_AND:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[75] = jj_gen; |
| break label_32; |
| } |
| jj_consume_token(BIT_AND); |
| right = EqualityExpression(); |
| ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.BINARY_AND); |
| } |
| return ret; |
| } |
| |
| final public Expression EqualityExpression() throws ParseException {Expression ret; |
| Expression right; |
| BinaryExpr.Operator op; |
| ret = InstanceOfExpression(); |
| label_33: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case EQ: |
| case NE:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[76] = jj_gen; |
| break label_33; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case EQ:{ |
| jj_consume_token(EQ); |
| op = BinaryExpr.Operator.EQUALS; |
| break; |
| } |
| case NE:{ |
| jj_consume_token(NE); |
| op = BinaryExpr.Operator.NOT_EQUALS; |
| break; |
| } |
| default: |
| jj_la1[77] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| right = InstanceOfExpression(); |
| ret = new BinaryExpr(range(ret, token()), ret, right, op); |
| } |
| return ret; |
| } |
| |
| final public Expression InstanceOfExpression() throws ParseException {Expression ret; |
| ReferenceType type; |
| NodeList<AnnotationExpr> annotations; |
| ret = RelationalExpression(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case INSTANCEOF:{ |
| jj_consume_token(INSTANCEOF); |
| type = AnnotatedReferenceType(); |
| ret = new InstanceOfExpr(range(ret, token()), ret, type); |
| break; |
| } |
| default: |
| jj_la1[78] = jj_gen; |
| ; |
| } |
| return ret; |
| } |
| |
| final public Expression RelationalExpression() throws ParseException {Expression ret; |
| Expression right; |
| BinaryExpr.Operator op; |
| ret = ShiftExpression(); |
| label_34: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT: |
| case LE: |
| case GE: |
| case GT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[79] = jj_gen; |
| break label_34; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| jj_consume_token(LT); |
| op = BinaryExpr.Operator.LESS; |
| break; |
| } |
| case GT:{ |
| jj_consume_token(GT); |
| op = BinaryExpr.Operator.GREATER; |
| break; |
| } |
| case LE:{ |
| jj_consume_token(LE); |
| op = BinaryExpr.Operator.LESS_EQUALS; |
| break; |
| } |
| case GE:{ |
| jj_consume_token(GE); |
| op = BinaryExpr.Operator.GREATER_EQUALS; |
| break; |
| } |
| default: |
| jj_la1[80] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| right = ShiftExpression(); |
| ret = new BinaryExpr(range(ret, token()), ret, right, op); |
| } |
| return ret; |
| } |
| |
| final public Expression ShiftExpression() throws ParseException {Expression ret; |
| Expression right; |
| BinaryExpr.Operator op; |
| ret = AdditiveExpression(); |
| label_35: |
| while (true) { |
| if (jj_2_25(1)) { |
| ; |
| } else { |
| break label_35; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LSHIFT:{ |
| jj_consume_token(LSHIFT); |
| op = BinaryExpr.Operator.LEFT_SHIFT; |
| break; |
| } |
| default: |
| jj_la1[81] = jj_gen; |
| if (jj_2_26(1)) { |
| RSIGNEDSHIFT(); |
| op = BinaryExpr.Operator.SIGNED_RIGHT_SHIFT; |
| } else if (jj_2_27(1)) { |
| RUNSIGNEDSHIFT(); |
| op = BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT; |
| } else { |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| right = AdditiveExpression(); |
| ret = new BinaryExpr(range(ret, token()), ret, right, op); |
| } |
| return ret; |
| } |
| |
| final public Expression AdditiveExpression() throws ParseException {Expression ret; |
| Expression right; |
| BinaryExpr.Operator op; |
| ret = MultiplicativeExpression(); |
| label_36: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case PLUS: |
| case MINUS:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[82] = jj_gen; |
| break label_36; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case PLUS:{ |
| jj_consume_token(PLUS); |
| op = BinaryExpr.Operator.PLUS; |
| break; |
| } |
| case MINUS:{ |
| jj_consume_token(MINUS); |
| op = BinaryExpr.Operator.MINUS; |
| break; |
| } |
| default: |
| jj_la1[83] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| right = MultiplicativeExpression(); |
| ret = new BinaryExpr(range(ret, token()), ret, right, op); |
| } |
| return ret; |
| } |
| |
| final public Expression MultiplicativeExpression() throws ParseException {Expression ret; |
| Expression right; |
| BinaryExpr.Operator op; |
| ret = UnaryExpression(); |
| label_37: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case STAR: |
| case SLASH: |
| case REM:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[84] = jj_gen; |
| break label_37; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case STAR:{ |
| jj_consume_token(STAR); |
| op = BinaryExpr.Operator.MULTIPLY; |
| break; |
| } |
| case SLASH:{ |
| jj_consume_token(SLASH); |
| op = BinaryExpr.Operator.DIVIDE; |
| break; |
| } |
| case REM:{ |
| jj_consume_token(REM); |
| op = BinaryExpr.Operator.REMAINDER; |
| break; |
| } |
| default: |
| jj_la1[85] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| right = UnaryExpression(); |
| ret = new BinaryExpr(range(ret, token()), ret, right, op); |
| } |
| return ret; |
| } |
| |
| final public Expression UnaryExpression() throws ParseException {Expression ret; |
| UnaryExpr.Operator op; |
| JavaToken begin = INVALID; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case INCR:{ |
| ret = PreIncrementExpression(); |
| break; |
| } |
| case DECR:{ |
| ret = PreDecrementExpression(); |
| break; |
| } |
| case PLUS: |
| case MINUS:{ |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case PLUS:{ |
| jj_consume_token(PLUS); |
| op = UnaryExpr.Operator.PLUS; begin=token(); |
| break; |
| } |
| case MINUS:{ |
| jj_consume_token(MINUS); |
| op = UnaryExpr.Operator.MINUS; begin=token(); |
| break; |
| } |
| default: |
| jj_la1[86] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = UnaryExpression(); |
| ret = new UnaryExpr(range(begin, token()), ret, op); |
| break; |
| } |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE:{ |
| ret = UnaryExpressionNotPlusMinus(); |
| break; |
| } |
| default: |
| jj_la1[87] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Expression PreIncrementExpression() throws ParseException {Expression ret; |
| JavaToken begin = INVALID; |
| jj_consume_token(INCR); |
| begin=token(); |
| ret = UnaryExpression(); |
| ret = new UnaryExpr(range(begin, token()), ret, UnaryExpr.Operator.PREFIX_INCREMENT); |
| return ret; |
| } |
| |
| final public Expression PreDecrementExpression() throws ParseException {Expression ret; |
| JavaToken begin; |
| jj_consume_token(DECR); |
| begin=token(); |
| ret = UnaryExpression(); |
| ret = new UnaryExpr(range(begin, token()), ret, UnaryExpr.Operator.PREFIX_DECREMENT); |
| return ret; |
| } |
| |
| final public Expression UnaryExpressionNotPlusMinus() throws ParseException {Expression ret; |
| UnaryExpr.Operator op; |
| JavaToken begin = INVALID; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BANG: |
| case TILDE:{ |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case TILDE:{ |
| jj_consume_token(TILDE); |
| op = UnaryExpr.Operator.BITWISE_COMPLEMENT; begin=token(); |
| break; |
| } |
| case BANG:{ |
| jj_consume_token(BANG); |
| op = UnaryExpr.Operator.LOGICAL_COMPLEMENT; begin=token(); |
| break; |
| } |
| default: |
| jj_la1[88] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = UnaryExpression(); |
| ret = new UnaryExpr(range(begin, token()), ret, op); |
| break; |
| } |
| default: |
| jj_la1[89] = jj_gen; |
| if (jj_2_28(2147483647)) { |
| ret = CastExpression(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT:{ |
| ret = PostfixExpression(); |
| break; |
| } |
| default: |
| jj_la1[90] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| final public Expression PostfixExpression() throws ParseException {Expression ret; |
| UnaryExpr.Operator op; |
| ret = PrimaryExpression(); |
| if (jj_2_29(2)) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case INCR:{ |
| jj_consume_token(INCR); |
| op = UnaryExpr.Operator.POSTFIX_INCREMENT; |
| break; |
| } |
| case DECR:{ |
| jj_consume_token(DECR); |
| op = UnaryExpr.Operator.POSTFIX_DECREMENT; |
| break; |
| } |
| default: |
| jj_la1[91] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = new UnaryExpr(range(ret, token()), ret, op); |
| } else { |
| ; |
| } |
| return ret; |
| } |
| |
| final public Expression CastExpression() throws ParseException {Expression ret; |
| ReferenceType referenceType; |
| PrimitiveType primitiveType; |
| JavaToken begin = INVALID; |
| NodeList<AnnotationExpr> annotations; |
| NodeList<ReferenceType> typesOfMultiCast = emptyList(); |
| jj_consume_token(LPAREN); |
| begin=token(); |
| annotations = Annotations(); |
| if (jj_2_30(2)) { |
| primitiveType = PrimitiveType(annotations); |
| jj_consume_token(RPAREN); |
| ret = UnaryExpression(); |
| ret = new CastExpr(range(begin, token()), primitiveType, ret); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| referenceType = ReferenceType(annotations); |
| typesOfMultiCast = add(typesOfMultiCast, referenceType); |
| label_38: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BIT_AND:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[92] = jj_gen; |
| break label_38; |
| } |
| jj_consume_token(BIT_AND); |
| referenceType = AnnotatedReferenceType(); |
| typesOfMultiCast = add(typesOfMultiCast, referenceType); |
| } |
| jj_consume_token(RPAREN); |
| ret = UnaryExpressionNotPlusMinus(); |
| if (typesOfMultiCast.size() > 1) { |
| ret = new CastExpr(range(begin, token()), new IntersectionType(range(typesOfMultiCast.get(0), typesOfMultiCast.get(typesOfMultiCast.size() -1)), typesOfMultiCast), ret); |
| } else { |
| ret = new CastExpr(range(begin, token()), referenceType, ret); |
| } |
| break; |
| } |
| default: |
| jj_la1[93] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public Expression PrimaryExpression() throws ParseException {Expression ret; |
| ret = PrimaryPrefix(); |
| label_39: |
| while (true) { |
| if (jj_2_31(2)) { |
| ; |
| } else { |
| break label_39; |
| } |
| ret = PrimarySuffix(ret); |
| } |
| return ret; |
| } |
| |
| final public Expression PrimaryExpressionWithoutSuperSuffix() throws ParseException {Expression ret; |
| ret = PrimaryPrefix(); |
| label_40: |
| while (true) { |
| if (jj_2_32(2147483647)) { |
| ; |
| } else { |
| break label_40; |
| } |
| ret = PrimarySuffixWithoutSuper(ret); |
| } |
| return ret; |
| } |
| |
| final public Expression PrimaryPrefix() throws ParseException {Expression ret = null; |
| SimpleName name; |
| RangedList<Type> typeArgs = new RangedList<Type>(null); |
| NodeList<Expression> args = emptyList(); |
| NodeList<Parameter> params = emptyList(); |
| boolean hasArgs = false; |
| boolean isLambda = false; |
| Type type; |
| JavaToken begin; |
| Parameter p = null; |
| SimpleName id = null; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case FALSE: |
| case NULL: |
| case TRUE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL:{ |
| ret = Literal(); |
| break; |
| } |
| case THIS:{ |
| jj_consume_token(THIS); |
| ret = new ThisExpr(tokenRange(), null); |
| break; |
| } |
| case SUPER:{ |
| jj_consume_token(SUPER); |
| ret = new SuperExpr(tokenRange(), null); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case DOT:{ |
| jj_consume_token(DOT); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| break; |
| } |
| default: |
| jj_la1[94] = jj_gen; |
| ; |
| } |
| name = SimpleName(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LPAREN:{ |
| args = Arguments(); |
| hasArgs=true; |
| break; |
| } |
| default: |
| jj_la1[95] = jj_gen; |
| ; |
| } |
| if (hasArgs) { |
| ret = new MethodCallExpr(range(ret, token()), ret, typeArgs.list, name, args); |
| } else { |
| ret = new FieldAccessExpr(range(ret, token()), ret, emptyList(), name); |
| } |
| break; |
| } |
| case DOUBLECOLON:{ |
| jj_consume_token(DOUBLECOLON); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| break; |
| } |
| default: |
| jj_la1[96] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ENUM: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| Identifier(); |
| break; |
| } |
| case NEW:{ |
| jj_consume_token(NEW); |
| break; |
| } |
| default: |
| jj_la1[97] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image); |
| break; |
| } |
| default: |
| jj_la1[98] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| } |
| case LPAREN:{ |
| jj_consume_token(LPAREN); |
| begin=token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case RPAREN:{ |
| jj_consume_token(RPAREN); |
| ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true); |
| break; |
| } |
| default: |
| jj_la1[99] = jj_gen; |
| if (jj_2_33(2147483647)) { |
| params = LambdaParameters(); |
| jj_consume_token(RPAREN); |
| ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true); |
| } else if (jj_2_34(2147483647)) { |
| params = InferredLambdaParameters(); |
| jj_consume_token(RPAREN); |
| ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| // This could still be a lambda expression, but this is handled after matching -> elsewhere |
| ret = Expression(); |
| jj_consume_token(RPAREN); |
| ret = new EnclosedExpr(range(begin, token()), ret); |
| break; |
| } |
| default: |
| jj_la1[100] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| break; |
| } |
| case NEW:{ |
| ret = AllocationExpression(null); |
| break; |
| } |
| default: |
| jj_la1[104] = jj_gen; |
| if (jj_2_35(2147483647)) { |
| type = ResultType(emptyList()); |
| jj_consume_token(DOT); |
| jj_consume_token(CLASS); |
| ret = new ClassExpr(range(type, token()), type); |
| } else if (jj_2_36(2147483647)) { |
| type = AnnotatedType(); |
| jj_consume_token(DOUBLECOLON); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| break; |
| } |
| default: |
| jj_la1[101] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ENUM: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| Identifier(); |
| break; |
| } |
| case NEW:{ |
| jj_consume_token(NEW); |
| break; |
| } |
| default: |
| jj_la1[102] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = new TypeExpr(range(type, type), type); |
| ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ENUM: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| name = SimpleName(); |
| begin=token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LPAREN:{ |
| args = Arguments(); |
| hasArgs=true; |
| break; |
| } |
| default: |
| jj_la1[103] = jj_gen; |
| ; |
| } |
| if (hasArgs) { |
| ret = new MethodCallExpr(range(begin, token()), null, null, name, args); |
| } else { |
| ret = new NameExpr(name); |
| } |
| break; |
| } |
| default: |
| jj_la1[105] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| final public Expression PrimarySuffix(Expression scope) throws ParseException {Expression ret; |
| if (jj_2_37(2)) { |
| ret = PrimarySuffixWithoutSuper(scope); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case DOT:{ |
| jj_consume_token(DOT); |
| jj_consume_token(SUPER); |
| ret = new SuperExpr(range(scope, token()), scope); |
| break; |
| } |
| default: |
| jj_la1[106] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public Expression PrimarySuffixWithoutSuper(Expression scope) throws ParseException {Expression ret; |
| RangedList<Type> typeArgs = new RangedList<Type>(null); |
| NodeList<Expression> args = emptyList(); |
| boolean hasArgs = false; |
| SimpleName name; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case DOT:{ |
| jj_consume_token(DOT); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case THIS:{ |
| jj_consume_token(THIS); |
| ret = new ThisExpr(range(scope, token()), scope); |
| break; |
| } |
| case NEW:{ |
| ret = AllocationExpression(scope); |
| break; |
| } |
| default: |
| jj_la1[109] = jj_gen; |
| if (jj_2_38(2147483647)) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| break; |
| } |
| default: |
| jj_la1[107] = jj_gen; |
| ; |
| } |
| name = SimpleName(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LPAREN:{ |
| args = Arguments(); |
| hasArgs=true; |
| break; |
| } |
| default: |
| jj_la1[108] = jj_gen; |
| ; |
| } |
| if (hasArgs) { |
| ret = new MethodCallExpr(range(scope, token()), scope, typeArgs.list, name, args); |
| } else { |
| ret = new FieldAccessExpr(range(scope, token()), scope, typeArgs.list, name); |
| } |
| } else { |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| break; |
| } |
| case LBRACKET:{ |
| jj_consume_token(LBRACKET); |
| ret = Expression(); |
| jj_consume_token(RBRACKET); |
| ret = new ArrayAccessExpr(range(scope, token()), scope, ret); |
| break; |
| } |
| default: |
| jj_la1[110] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Expression Literal() throws ParseException {Expression ret; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case INTEGER_LITERAL:{ |
| jj_consume_token(INTEGER_LITERAL); |
| ret = new IntegerLiteralExpr(tokenRange(), token.image); |
| break; |
| } |
| case LONG_LITERAL:{ |
| jj_consume_token(LONG_LITERAL); |
| ret = new LongLiteralExpr(tokenRange(), token.image); |
| break; |
| } |
| case FLOATING_POINT_LITERAL:{ |
| jj_consume_token(FLOATING_POINT_LITERAL); |
| ret = new DoubleLiteralExpr(tokenRange(), token.image); |
| break; |
| } |
| case CHARACTER_LITERAL:{ |
| jj_consume_token(CHARACTER_LITERAL); |
| ret = new CharLiteralExpr(tokenRange(), token.image.substring(1, token.image.length()-1)); |
| break; |
| } |
| case STRING_LITERAL:{ |
| jj_consume_token(STRING_LITERAL); |
| ret = new StringLiteralExpr(tokenRange(), token.image.substring(1, token.image.length()-1)); |
| break; |
| } |
| case FALSE: |
| case TRUE:{ |
| ret = BooleanLiteral(); |
| break; |
| } |
| case NULL:{ |
| ret = NullLiteral(); |
| break; |
| } |
| default: |
| jj_la1[111] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Expression BooleanLiteral() throws ParseException {Expression ret; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case TRUE:{ |
| jj_consume_token(TRUE); |
| ret = new BooleanLiteralExpr(tokenRange(), true); |
| break; |
| } |
| case FALSE:{ |
| jj_consume_token(FALSE); |
| ret = new BooleanLiteralExpr(tokenRange(), false); |
| break; |
| } |
| default: |
| jj_la1[112] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Expression NullLiteral() throws ParseException { |
| jj_consume_token(NULL); |
| return new NullLiteralExpr(tokenRange()); |
| } |
| |
| final public NodeList<Expression> Arguments() throws ParseException {NodeList<Expression> ret = emptyList(); |
| jj_consume_token(LPAREN); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| ret = ArgumentList(); |
| break; |
| } |
| default: |
| jj_la1[113] = jj_gen; |
| ; |
| } |
| jj_consume_token(RPAREN); |
| return ret; |
| } |
| |
| final public NodeList<Expression> ArgumentList() throws ParseException {NodeList<Expression> ret = emptyList(); |
| Expression expr; |
| expr = Expression(); |
| ret.add(expr); |
| label_41: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[114] = jj_gen; |
| break label_41; |
| } |
| jj_consume_token(COMMA); |
| expr = Expression(); |
| ret.add(expr); |
| } |
| return ret; |
| } |
| |
| final public Expression AllocationExpression(Expression scope) throws ParseException {Expression ret; |
| Type type; |
| RangedList<Type> typeArgs = new RangedList<Type>(null); |
| NodeList<BodyDeclaration<?>> anonymousBody = null; |
| NodeList<Expression> args; |
| JavaToken begin = INVALID; |
| NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>(); |
| jj_consume_token(NEW); |
| if(scope==null) {begin=token();} else {begin = orIfInvalid(begin, scope);} |
| annotations = Annotations(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT:{ |
| type = PrimitiveType(annotations); |
| ret = ArrayCreation(begin, type); |
| break; |
| } |
| case ENUM: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case AT: |
| case LT:{ |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| break; |
| } |
| default: |
| jj_la1[115] = jj_gen; |
| ; |
| } |
| type = AnnotatedClassOrInterfaceType(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACKET: |
| case AT:{ |
| ret = ArrayCreation(begin, type); |
| break; |
| } |
| case LPAREN:{ |
| args = Arguments(); |
| if (jj_2_39(2)) { |
| anonymousBody = ClassOrInterfaceBody(); |
| } else { |
| ; |
| } |
| ret = new ObjectCreationExpr(range(begin, token()), scope, (ClassOrInterfaceType) type, typeArgs.list, args, anonymousBody); |
| break; |
| } |
| default: |
| jj_la1[116] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| } |
| default: |
| jj_la1[117] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public ArrayCreationExpr ArrayCreation(JavaToken begin, Type type) throws ParseException {Expression expr = null; |
| ArrayInitializerExpr arrayInitializerExpr = null; |
| NodeList<Expression> inits = emptyList(); |
| List<NodeList<AnnotationExpr>> accum = new ArrayList<NodeList<AnnotationExpr>>(); |
| NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>(); |
| JavaToken arrayCreationLevelStart = INVALID; |
| List<TokenRange> levelRanges = new ArrayList<TokenRange>(); |
| label_42: |
| while (true) { |
| annotations = Annotations(); |
| jj_consume_token(LBRACKET); |
| arrayCreationLevelStart = annotations.isEmpty() ? token() : orIfInvalid(arrayCreationLevelStart, annotations.get(0)); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| expr = Expression(); |
| break; |
| } |
| default: |
| jj_la1[118] = jj_gen; |
| ; |
| } |
| accum = add(accum, annotations); inits = add(inits, expr); annotations=null; expr=null; |
| jj_consume_token(RBRACKET); |
| levelRanges.add(range(arrayCreationLevelStart, token())); |
| if (jj_2_40(2)) { |
| ; |
| } else { |
| break label_42; |
| } |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACE:{ |
| arrayInitializerExpr = ArrayInitializer(); |
| break; |
| } |
| default: |
| jj_la1[119] = jj_gen; |
| ; |
| } |
| return juggleArrayCreation(range(begin, token()), levelRanges, type, inits, accum, arrayInitializerExpr); |
| } |
| |
| /* |
| * Statement syntax follows. |
| */ |
| final public |
| Statement Statement() throws ParseException {Statement ret; |
| try { |
| if (jj_2_41(2)) { |
| ret = LabeledStatement(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ASSERT:{ |
| ret = AssertStatement(); |
| break; |
| } |
| case LBRACE:{ |
| ret = Block(); |
| break; |
| } |
| case SEMICOLON:{ |
| ret = EmptyStatement(); |
| break; |
| } |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case INCR: |
| case DECR:{ |
| ret = StatementExpression(); |
| break; |
| } |
| case SWITCH:{ |
| ret = SwitchStatement(); |
| break; |
| } |
| case IF:{ |
| ret = IfStatement(); |
| break; |
| } |
| case WHILE:{ |
| ret = WhileStatement(); |
| break; |
| } |
| case DO:{ |
| ret = DoStatement(); |
| break; |
| } |
| case FOR:{ |
| ret = ForStatement(); |
| break; |
| } |
| case BREAK:{ |
| ret = BreakStatement(); |
| break; |
| } |
| case CONTINUE:{ |
| ret = ContinueStatement(); |
| break; |
| } |
| case RETURN:{ |
| ret = ReturnStatement(); |
| break; |
| } |
| case THROW:{ |
| ret = ThrowStatement(); |
| break; |
| } |
| case SYNCHRONIZED:{ |
| ret = SynchronizedStatement(); |
| break; |
| } |
| case TRY:{ |
| ret = TryStatement(); |
| break; |
| } |
| default: |
| jj_la1[120] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } catch (ParseException e) { |
| TokenRange errorRange = recover(SEMICOLON, e); |
| return new UnparsableStmt(errorRange); |
| } |
| } |
| |
| final public AssertStmt AssertStatement() throws ParseException {Expression check; |
| Expression msg = null; |
| JavaToken begin; |
| jj_consume_token(ASSERT); |
| begin=token(); |
| check = Expression(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COLON:{ |
| jj_consume_token(COLON); |
| msg = Expression(); |
| break; |
| } |
| default: |
| jj_la1[121] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| return new AssertStmt(range(begin, token()), check, msg); |
| } |
| |
| final public LabeledStmt LabeledStatement() throws ParseException {SimpleName label; |
| Statement stmt; |
| JavaToken begin; |
| label = SimpleName(); |
| begin=token(); |
| jj_consume_token(COLON); |
| stmt = Statement(); |
| return new LabeledStmt(range(begin, token()), label, stmt); |
| } |
| |
| final public BlockStmt Block() throws ParseException {NodeList<Statement> stmts = emptyList(); |
| JavaToken begin; |
| jj_consume_token(LBRACE); |
| begin=token(); |
| try { |
| stmts = Statements(); |
| jj_consume_token(RBRACE); |
| return new BlockStmt(range(begin, token()), stmts); |
| } catch (ParseException e) { |
| recover(RBRACE, e); |
| BlockStmt block = new BlockStmt(range(begin, token()), new NodeList<Statement>()); |
| block.setParsed(UNPARSABLE); |
| return block; |
| } |
| } |
| |
| /* |
| * Classes inside body statements can only be abstract or final. The semantic must check it. |
| */ |
| final public Statement BlockStatement() throws ParseException {Statement ret; |
| Expression expr; |
| ClassOrInterfaceDeclaration typeDecl; |
| ModifierHolder modifier; |
| try { |
| if (jj_2_42(2147483647)) { |
| modifier = Modifiers(); |
| typeDecl = ClassOrInterfaceDeclaration(modifier); |
| ret = new LocalClassDeclarationStmt(range(typeDecl, token()), typeDecl); |
| } else if (jj_2_43(2147483647)) { |
| expr = VariableDeclarationExpression(); |
| jj_consume_token(SEMICOLON); |
| ret = new ExpressionStmt(range(expr, token()), expr); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ASSERT: |
| case BOOLEAN: |
| case BREAK: |
| case BYTE: |
| case CHAR: |
| case CONTINUE: |
| case DO: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case FOR: |
| case IF: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case RETURN: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case SWITCH: |
| case SYNCHRONIZED: |
| case THIS: |
| case THROW: |
| case TRUE: |
| case TRY: |
| case VOID: |
| case WHILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case LBRACE: |
| case SEMICOLON: |
| case AT: |
| case INCR: |
| case DECR:{ |
| ret = Statement(); |
| break; |
| } |
| default: |
| jj_la1[122] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } catch (ParseException e) { |
| TokenRange errorRange = recover(SEMICOLON, e); |
| return new UnparsableStmt(errorRange); |
| } |
| } |
| |
| final public VariableDeclarationExpr VariableDeclarationExpression() throws ParseException {ModifierHolder modifier; |
| Type partialType; |
| NodeList<VariableDeclarator> variables = new NodeList<VariableDeclarator>(); |
| VariableDeclarator var; |
| modifier = Modifiers(); |
| partialType = Type(emptyList()); |
| var = VariableDeclarator(partialType); |
| variables.add(var); |
| label_43: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[123] = jj_gen; |
| break label_43; |
| } |
| jj_consume_token(COMMA); |
| var = VariableDeclarator(partialType); |
| variables.add(var); |
| } |
| JavaToken begin=orIfInvalid(modifier.begin, partialType); |
| return new VariableDeclarationExpr(range(begin, token()), modifier.modifiers, modifier.annotations, variables); |
| } |
| |
| final public EmptyStmt EmptyStatement() throws ParseException { |
| jj_consume_token(SEMICOLON); |
| return new EmptyStmt(tokenRange()); |
| } |
| |
| final public Statement LambdaBody() throws ParseException {Expression expr; |
| Statement n = null; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| expr = Expression(); |
| n = new ExpressionStmt(range(expr, token()), expr); |
| break; |
| } |
| case LBRACE:{ |
| n = Block(); |
| break; |
| } |
| default: |
| jj_la1[124] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return n; |
| } |
| |
| final public ExpressionStmt StatementExpression() throws ParseException {Expression expr; |
| AssignExpr.Operator op; |
| Expression value; |
| RangedList<Type> typeArgs = new RangedList<Type>(null); |
| Statement lambdaBody; |
| if (jj_2_44(2)) { |
| expr = PreIncrementExpression(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case DECR:{ |
| expr = PreDecrementExpression(); |
| break; |
| } |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT:{ |
| expr = PrimaryExpression(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ASSIGN: |
| case INCR: |
| case DECR: |
| case PLUSASSIGN: |
| case MINUSASSIGN: |
| case STARASSIGN: |
| case SLASHASSIGN: |
| case ANDASSIGN: |
| case ORASSIGN: |
| case XORASSIGN: |
| case REMASSIGN: |
| case LSHIFTASSIGN: |
| case RSIGNEDSHIFTASSIGN: |
| case RUNSIGNEDSHIFTASSIGN:{ |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case INCR:{ |
| jj_consume_token(INCR); |
| expr = new UnaryExpr(range(expr, token()), expr, UnaryExpr.Operator.POSTFIX_INCREMENT); |
| break; |
| } |
| case DECR:{ |
| jj_consume_token(DECR); |
| expr = new UnaryExpr(range(expr, token()), expr, UnaryExpr.Operator.POSTFIX_DECREMENT); |
| break; |
| } |
| case ASSIGN: |
| case PLUSASSIGN: |
| case MINUSASSIGN: |
| case STARASSIGN: |
| case SLASHASSIGN: |
| case ANDASSIGN: |
| case ORASSIGN: |
| case XORASSIGN: |
| case REMASSIGN: |
| case LSHIFTASSIGN: |
| case RSIGNEDSHIFTASSIGN: |
| case RUNSIGNEDSHIFTASSIGN:{ |
| op = AssignmentOperator(); |
| value = Expression(); |
| expr = new AssignExpr(range(expr, token()), expr, value, op); |
| break; |
| } |
| default: |
| jj_la1[125] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| } |
| default: |
| jj_la1[126] = jj_gen; |
| ; |
| } |
| break; |
| } |
| default: |
| jj_la1[127] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| jj_consume_token(SEMICOLON); |
| return new ExpressionStmt(range(expr, token()), expr); |
| } |
| |
| final public SwitchStmt SwitchStatement() throws ParseException {Expression selector; |
| SwitchEntryStmt entry; |
| NodeList<SwitchEntryStmt> entries = emptyList(); |
| JavaToken begin; |
| jj_consume_token(SWITCH); |
| begin=token(); |
| jj_consume_token(LPAREN); |
| selector = Expression(); |
| jj_consume_token(RPAREN); |
| jj_consume_token(LBRACE); |
| label_44: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CASE: |
| case _DEFAULT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[128] = jj_gen; |
| break label_44; |
| } |
| entry = SwitchEntry(); |
| entries = add(entries, entry); |
| } |
| jj_consume_token(RBRACE); |
| return new SwitchStmt(range(begin, token()), selector, entries); |
| } |
| |
| final public SwitchEntryStmt SwitchEntry() throws ParseException {Expression label = null; |
| NodeList<Statement> stmts; |
| JavaToken begin; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CASE:{ |
| jj_consume_token(CASE); |
| begin=token(); |
| label = Expression(); |
| break; |
| } |
| case _DEFAULT:{ |
| jj_consume_token(_DEFAULT); |
| begin=token(); |
| break; |
| } |
| default: |
| jj_la1[129] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jj_consume_token(COLON); |
| stmts = Statements(); |
| return new SwitchEntryStmt(range(begin, token()),label, stmts); |
| } |
| |
| final public IfStmt IfStatement() throws ParseException {Expression condition; |
| Statement thenStmt; |
| Statement elseStmt = null; |
| JavaToken begin; |
| jj_consume_token(IF); |
| begin=token(); |
| jj_consume_token(LPAREN); |
| condition = Expression(); |
| jj_consume_token(RPAREN); |
| |
| thenStmt = Statement(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ELSE:{ |
| jj_consume_token(ELSE); |
| |
| elseStmt = Statement(); |
| break; |
| } |
| default: |
| jj_la1[130] = jj_gen; |
| ; |
| } |
| return new IfStmt(range(begin, token()), condition, thenStmt, elseStmt); |
| } |
| |
| final public WhileStmt WhileStatement() throws ParseException {Expression condition; |
| Statement body; |
| JavaToken begin; |
| jj_consume_token(WHILE); |
| begin=token(); |
| jj_consume_token(LPAREN); |
| condition = Expression(); |
| jj_consume_token(RPAREN); |
| body = Statement(); |
| return new WhileStmt(range(begin, token()),condition, body); |
| } |
| |
| final public DoStmt DoStatement() throws ParseException {Expression condition; |
| Statement body; |
| JavaToken begin; |
| jj_consume_token(DO); |
| begin=token(); |
| body = Statement(); |
| jj_consume_token(WHILE); |
| jj_consume_token(LPAREN); |
| condition = Expression(); |
| jj_consume_token(RPAREN); |
| jj_consume_token(SEMICOLON); |
| return new DoStmt(range(begin, token()),body, condition); |
| } |
| |
| final public Statement ForStatement() throws ParseException {VariableDeclarationExpr varExpr = null; |
| Expression expr = null; |
| NodeList<Expression> init = emptyList(); |
| NodeList<Expression> update = emptyList(); |
| Statement body; |
| JavaToken begin; |
| jj_consume_token(FOR); |
| begin=token(); |
| jj_consume_token(LPAREN); |
| if (jj_2_45(2147483647)) { |
| varExpr = VariableDeclarationExpression(); |
| jj_consume_token(COLON); |
| expr = Expression(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NATIVE: |
| case NEW: |
| case NULL: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SUPER: |
| case SYNCHRONIZED: |
| case THIS: |
| case TRANSIENT: |
| case TRUE: |
| case VOID: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case SEMICOLON: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NATIVE: |
| case NEW: |
| case NULL: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SUPER: |
| case SYNCHRONIZED: |
| case THIS: |
| case TRANSIENT: |
| case TRUE: |
| case VOID: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| init = ForInit(); |
| break; |
| } |
| default: |
| jj_la1[131] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| expr = Expression(); |
| break; |
| } |
| default: |
| jj_la1[132] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| update = ForUpdate(); |
| break; |
| } |
| default: |
| jj_la1[133] = jj_gen; |
| ; |
| } |
| break; |
| } |
| default: |
| jj_la1[134] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| jj_consume_token(RPAREN); |
| body = Statement(); |
| if (varExpr != null) { |
| return new ForeachStmt(range(begin, token()),varExpr, expr, body); |
| } |
| return new ForStmt(range(begin, token()),init, expr, update, body); |
| } |
| |
| final public NodeList<Expression> ForInit() throws ParseException {NodeList<Expression> ret; |
| Expression expr; |
| if (jj_2_46(2147483647)) { |
| expr = VariableDeclarationExpression(); |
| ret = new NodeList<Expression>(); ret.add(expr); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| ret = ExpressionList(); |
| break; |
| } |
| default: |
| jj_la1[135] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public NodeList<Expression> ExpressionList() throws ParseException {NodeList<Expression> ret = new NodeList<Expression>(); |
| Expression expr; |
| expr = Expression(); |
| ret.add(expr); |
| label_45: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[136] = jj_gen; |
| break label_45; |
| } |
| jj_consume_token(COMMA); |
| expr = Expression(); |
| ret.add(expr); |
| } |
| return ret; |
| } |
| |
| final public NodeList<Expression> ForUpdate() throws ParseException {NodeList<Expression> ret; |
| ret = ExpressionList(); |
| return ret; |
| } |
| |
| final public BreakStmt BreakStatement() throws ParseException {SimpleName label = null; |
| JavaToken begin; |
| jj_consume_token(BREAK); |
| begin=token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ENUM: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| label = SimpleName(); |
| break; |
| } |
| default: |
| jj_la1[137] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| return new BreakStmt(range(begin, token()), label); |
| } |
| |
| final public ContinueStmt ContinueStatement() throws ParseException {SimpleName label = null; |
| JavaToken begin; |
| jj_consume_token(CONTINUE); |
| begin=token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ENUM: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| label = SimpleName(); |
| break; |
| } |
| default: |
| jj_la1[138] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| return new ContinueStmt(range(begin, token()), label); |
| } |
| |
| final public ReturnStmt ReturnStatement() throws ParseException {Expression expr = null; |
| JavaToken begin; |
| jj_consume_token(RETURN); |
| begin=token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| expr = Expression(); |
| break; |
| } |
| default: |
| jj_la1[139] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| return new ReturnStmt(range(begin, token()),expr); |
| } |
| |
| final public ThrowStmt ThrowStatement() throws ParseException {Expression expr; |
| JavaToken begin; |
| jj_consume_token(THROW); |
| begin=token(); |
| expr = Expression(); |
| jj_consume_token(SEMICOLON); |
| return new ThrowStmt(range(begin, token()),expr); |
| } |
| |
| final public SynchronizedStmt SynchronizedStatement() throws ParseException {Expression expr; |
| BlockStmt body; |
| JavaToken begin; |
| jj_consume_token(SYNCHRONIZED); |
| begin=token(); |
| jj_consume_token(LPAREN); |
| expr = Expression(); |
| jj_consume_token(RPAREN); |
| body = Block(); |
| return new SynchronizedStmt(range(begin, token()),expr, body); |
| } |
| |
| final public TryStmt TryStatement() throws ParseException {NodeList<Expression> resources = emptyList(); |
| BlockStmt tryBlock; |
| BlockStmt finallyBlock = null; |
| NodeList<CatchClause> catchs = emptyList(); |
| BlockStmt catchBlock; |
| ModifierHolder exceptModifier; |
| ReferenceType exceptionType; |
| NodeList<ReferenceType> exceptionTypes = emptyList(); |
| Pair<SimpleName, List<ArrayBracketPair>> exceptId; |
| JavaToken begin; |
| JavaToken catchBegin; |
| JavaToken typesBegin; |
| JavaToken paramEnd; |
| Type type; |
| jj_consume_token(TRY); |
| begin=token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LPAREN:{ |
| resources = ResourceSpecification(); |
| break; |
| } |
| default: |
| jj_la1[140] = jj_gen; |
| ; |
| } |
| tryBlock = Block(); |
| label_46: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CATCH:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[141] = jj_gen; |
| break label_46; |
| } |
| jj_consume_token(CATCH); |
| catchBegin=token(); |
| jj_consume_token(LPAREN); |
| typesBegin=token(); |
| exceptModifier = Modifiers(); |
| exceptionType = ReferenceType(emptyList()); |
| exceptionTypes.add(exceptionType); |
| label_47: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BIT_OR:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[142] = jj_gen; |
| break label_47; |
| } |
| jj_consume_token(BIT_OR); |
| exceptionType = AnnotatedReferenceType(); |
| exceptionTypes.add(exceptionType); |
| } |
| exceptId = VariableDeclaratorId(); |
| paramEnd = token(); |
| jj_consume_token(RPAREN); |
| catchBlock = Block(); |
| if (exceptionTypes.size() > 1) { |
| type = new UnionType(range(exceptionTypes.get(0), exceptionTypes.get(exceptionTypes.size() - 1)), exceptionTypes); |
| } else { |
| type = (Type)exceptionTypes.get(0); |
| } |
| Parameter catchType = new Parameter(range(type, paramEnd), exceptModifier.modifiers, exceptModifier.annotations, type, false, emptyList(), exceptId.a); |
| catchs = add(catchs, new CatchClause(range(catchBegin, token()), catchType, catchBlock)); |
| exceptionTypes = emptyList(); |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case FINALLY:{ |
| jj_consume_token(FINALLY); |
| finallyBlock = Block(); |
| break; |
| } |
| default: |
| jj_la1[143] = jj_gen; |
| ; |
| } |
| return new TryStmt(range(begin, token()), resources, tryBlock, catchs, finallyBlock); |
| } |
| |
| final public NodeList<Expression> ResourceSpecification() throws ParseException {NodeList<Expression> variables; |
| jj_consume_token(LPAREN); |
| variables = Resources(); |
| if (jj_2_47(2)) { |
| jj_consume_token(SEMICOLON); |
| } else { |
| ; |
| } |
| jj_consume_token(RPAREN); |
| return variables; |
| } |
| |
| final public NodeList<Expression> Resources() throws ParseException {NodeList<Expression> expressions = new NodeList<Expression>(); |
| Expression expr; |
| expr = Resource(); |
| expressions.add(expr); |
| label_48: |
| while (true) { |
| if (jj_2_48(2)) { |
| ; |
| } else { |
| break label_48; |
| } |
| jj_consume_token(SEMICOLON); |
| expr = Resource(); |
| expressions.add(expr); |
| } |
| return expressions; |
| } |
| |
| final public Expression Resource() throws ParseException {Expression expr; |
| if (jj_2_49(2147483647)) { |
| /*this is a bit more lenient than we need to be, eg allowing access modifiers like private*/ |
| expr = VariableDeclarationExpression(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT:{ |
| expr = PrimaryExpression(); |
| break; |
| } |
| default: |
| jj_la1[144] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return expr; |
| } |
| |
| /* We use productions to match >>>, >> and > so that we can keep the |
| * type declaration syntax with generics clean |
| */ |
| final public |
| void RUNSIGNEDSHIFT() throws ParseException { |
| if (getToken(1).kind == GT && |
| getToken(1).realKind == RUNSIGNEDSHIFT) { |
| |
| } else { |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jj_consume_token(GT); |
| jj_consume_token(GT); |
| jj_consume_token(GT); |
| } |
| |
| final public void RSIGNEDSHIFT() throws ParseException { |
| if (getToken(1).kind == GT && |
| getToken(1).realKind == RSIGNEDSHIFT) { |
| |
| } else { |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jj_consume_token(GT); |
| jj_consume_token(GT); |
| } |
| |
| /* Annotation syntax follows. */ |
| final public |
| NodeList<AnnotationExpr> Annotations() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>(); |
| AnnotationExpr annotation; |
| label_49: |
| while (true) { |
| if (jj_2_50(2147483647)) { |
| ; |
| } else { |
| break label_49; |
| } |
| annotation = Annotation(); |
| annotations = add(annotations, annotation); |
| } |
| return annotations; |
| } |
| |
| final public AnnotationExpr Annotation() throws ParseException {AnnotationExpr ret; |
| Name name; |
| NodeList<MemberValuePair> pairs = emptyList(); |
| JavaToken begin; |
| Expression memberVal; |
| jj_consume_token(AT); |
| begin=token(); |
| name = Name(); |
| if (jj_2_51(2147483647)) { |
| jj_consume_token(LPAREN); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ENUM: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| pairs = MemberValuePairs(); |
| break; |
| } |
| default: |
| jj_la1[145] = jj_gen; |
| ; |
| } |
| jj_consume_token(RPAREN); |
| ret = new NormalAnnotationExpr(range(begin, token()), name, pairs); |
| } else if (jj_2_52(2147483647)) { |
| jj_consume_token(LPAREN); |
| memberVal = MemberValue(); |
| jj_consume_token(RPAREN); |
| ret = new SingleMemberAnnotationExpr(range(begin, token()), name, memberVal); |
| } else { |
| ret = new MarkerAnnotationExpr(range(begin, token()), name); |
| } |
| return ret; |
| } |
| |
| final public NodeList<MemberValuePair> MemberValuePairs() throws ParseException {NodeList<MemberValuePair> ret = new NodeList<MemberValuePair>(); |
| MemberValuePair pair; |
| pair = MemberValuePair(); |
| ret.add(pair); |
| label_50: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[146] = jj_gen; |
| break label_50; |
| } |
| jj_consume_token(COMMA); |
| pair = MemberValuePair(); |
| ret.add(pair); |
| } |
| return ret; |
| } |
| |
| final public MemberValuePair MemberValuePair() throws ParseException {SimpleName name; |
| Expression value; |
| JavaToken begin; |
| name = SimpleName(); |
| begin=token(); |
| jj_consume_token(ASSIGN); |
| value = MemberValue(); |
| return new MemberValuePair(range(begin, token()),name, value); |
| } |
| |
| final public Expression MemberValue() throws ParseException {Expression ret; |
| if (jj_2_53(2147483647)) { |
| ret = Annotation(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACE:{ |
| ret = MemberValueArrayInitializer(); |
| break; |
| } |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| ret = ConditionalExpression(); |
| break; |
| } |
| default: |
| jj_la1[147] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public Expression MemberValueArrayInitializer() throws ParseException {NodeList<Expression> ret = emptyList(); |
| Expression member; |
| JavaToken begin; |
| jj_consume_token(LBRACE); |
| begin=token(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case LBRACE: |
| case AT: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| member = MemberValue(); |
| ret.add(member); |
| label_51: |
| while (true) { |
| if (jj_2_54(2)) { |
| ; |
| } else { |
| break label_51; |
| } |
| jj_consume_token(COMMA); |
| member = MemberValue(); |
| ret.add(member); |
| } |
| break; |
| } |
| default: |
| jj_la1[148] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| jj_consume_token(COMMA); |
| break; |
| } |
| default: |
| jj_la1[149] = jj_gen; |
| ; |
| } |
| jj_consume_token(RBRACE); |
| return new ArrayInitializerExpr(range(begin, token()),ret); |
| } |
| |
| /* Annotation Types. */ |
| final public |
| AnnotationDeclaration AnnotationTypeDeclaration(ModifierHolder modifier) throws ParseException {SimpleName name; |
| NodeList<BodyDeclaration<?>> members = emptyList(); |
| JavaToken begin = modifier.begin; |
| jj_consume_token(AT); |
| begin=orIfInvalid(begin, token()); |
| jj_consume_token(INTERFACE); |
| name = SimpleName(); |
| members = AnnotationTypeBody(); |
| return new AnnotationDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, name, members); |
| } |
| |
| final public NodeList<BodyDeclaration<?>> AnnotationTypeBody() throws ParseException {NodeList<BodyDeclaration<?>> ret = emptyList(); |
| BodyDeclaration member; |
| jj_consume_token(LBRACE); |
| label_52: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case CLASS: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case INTERFACE: |
| case LONG: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case SEMICOLON: |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[150] = jj_gen; |
| break label_52; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case CLASS: |
| case _DEFAULT: |
| case DOUBLE: |
| case ENUM: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case INTERFACE: |
| case LONG: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOLATILE: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER: |
| case AT:{ |
| member = AnnotationBodyDeclaration(); |
| ret = addWhenNotNull(ret, member); |
| break; |
| } |
| case SEMICOLON:{ |
| jj_consume_token(SEMICOLON); |
| break; |
| } |
| default: |
| jj_la1[151] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| jj_consume_token(RBRACE); |
| return ret; |
| } |
| |
| final public BodyDeclaration<?> AnnotationBodyDeclaration() throws ParseException {ModifierHolder modifier; |
| BodyDeclaration ret; |
| modifier = Modifiers(); |
| if (jj_2_55(2147483647)) { |
| ret = AnnotationTypeMemberDeclaration(modifier); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CLASS: |
| case INTERFACE:{ |
| ret = ClassOrInterfaceDeclaration(modifier); |
| break; |
| } |
| default: |
| jj_la1[152] = jj_gen; |
| if (jj_2_56(2147483647)) { |
| ret = EnumDeclaration(modifier); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case AT:{ |
| ret = AnnotationTypeDeclaration(modifier); |
| break; |
| } |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| case STRICTFP: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case IDENTIFIER:{ |
| ret = FieldDeclaration(modifier); |
| break; |
| } |
| default: |
| jj_la1[153] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| } |
| return ret; |
| } |
| |
| final public AnnotationMemberDeclaration AnnotationTypeMemberDeclaration(ModifierHolder modifier) throws ParseException {Type type; |
| SimpleName name; |
| Expression defaultVal = null; |
| type = Type(emptyList()); |
| name = SimpleName(); |
| jj_consume_token(LPAREN); |
| jj_consume_token(RPAREN); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case _DEFAULT:{ |
| defaultVal = DefaultValue(); |
| break; |
| } |
| default: |
| jj_la1[154] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| JavaToken begin = orIfInvalid(modifier.begin, type); |
| return new AnnotationMemberDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, type, name, defaultVal); |
| } |
| |
| final public Expression DefaultValue() throws ParseException {Expression ret; |
| jj_consume_token(_DEFAULT); |
| ret = MemberValue(); |
| return ret; |
| } |
| |
| /* Module syntax follows */ |
| final public |
| |
| ModuleStmt ModuleStmt() throws ParseException {ModifierHolder modifiers; |
| Name name; |
| Name tmpName; |
| NodeList<Name> names=emptyList(); |
| Type type; |
| Type tmpType; |
| NodeList<Type> types=emptyList(); |
| JavaToken begin; |
| ModuleStmt stmt=new ModuleRequiresStmt(); |
| JavaToken transitiveExceptionalToken; |
| if (jj_2_57(2147483647)) { |
| jj_consume_token(REQUIRES); |
| begin=token(); |
| jj_consume_token(TRANSITIVE); |
| transitiveExceptionalToken=token(); setTokenKind(IDENTIFIER); |
| jj_consume_token(SEMICOLON); |
| stmt=new ModuleRequiresStmt(range(begin, token()), EnumSet.noneOf(Modifier.class), new Name(range(transitiveExceptionalToken, transitiveExceptionalToken), null, transitiveExceptionalToken.getText(), new NodeList<AnnotationExpr>())); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case REQUIRES:{ |
| jj_consume_token(REQUIRES); |
| begin=token(); |
| modifiers = Modifiers(); |
| name = Name(); |
| jj_consume_token(SEMICOLON); |
| stmt=new ModuleRequiresStmt(range(begin, token()), modifiers.modifiers, name); |
| break; |
| } |
| case EXPORTS:{ |
| jj_consume_token(EXPORTS); |
| begin=token(); |
| name = Name(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case TO:{ |
| jj_consume_token(TO); |
| tmpName = Name(); |
| names.add(tmpName); |
| label_53: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[155] = jj_gen; |
| break label_53; |
| } |
| jj_consume_token(COMMA); |
| tmpName = Name(); |
| names.add(tmpName); |
| } |
| break; |
| } |
| default: |
| jj_la1[156] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| stmt=new ModuleExportsStmt(range(begin, token()), name, names); |
| break; |
| } |
| case OPENS:{ |
| jj_consume_token(OPENS); |
| begin=token(); |
| name = Name(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case TO:{ |
| jj_consume_token(TO); |
| tmpName = Name(); |
| names.add(tmpName); |
| label_54: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[157] = jj_gen; |
| break label_54; |
| } |
| jj_consume_token(COMMA); |
| tmpName = Name(); |
| names.add(tmpName); |
| } |
| break; |
| } |
| default: |
| jj_la1[158] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| stmt=new ModuleOpensStmt(range(begin, token()), name, names); |
| break; |
| } |
| case USES:{ |
| jj_consume_token(USES); |
| begin=token(); |
| type = Type(emptyList()); |
| jj_consume_token(SEMICOLON); |
| stmt=new ModuleUsesStmt(range(begin, token()), type); |
| break; |
| } |
| case PROVIDES:{ |
| jj_consume_token(PROVIDES); |
| begin=token(); |
| type = Type(emptyList()); |
| jj_consume_token(WITH); |
| tmpType = Type(emptyList()); |
| types.add(tmpType); |
| label_55: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[159] = jj_gen; |
| break label_55; |
| } |
| jj_consume_token(COMMA); |
| tmpType = Type(emptyList()); |
| types.add(tmpType); |
| } |
| jj_consume_token(SEMICOLON); |
| stmt=new ModuleProvidesStmt(range(begin, token()), type, types); |
| break; |
| } |
| default: |
| jj_la1[160] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return stmt; |
| } |
| |
| final public ModuleDeclaration ModuleDeclaration(ModifierHolder modifier) throws ParseException {NodeList<ModuleStmt> statements = new NodeList<ModuleStmt>(); |
| boolean open=false; |
| ModuleStmt st; |
| Name name; |
| JavaToken begin = modifier.begin; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case OPEN:{ |
| jj_consume_token(OPEN); |
| open=true; begin = orIfInvalid(begin, token()); |
| break; |
| } |
| default: |
| jj_la1[161] = jj_gen; |
| ; |
| } |
| jj_consume_token(MODULE); |
| begin = orIfInvalid(begin, token()); |
| name = Name(); |
| jj_consume_token(LBRACE); |
| label_56: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case REQUIRES: |
| case OPENS: |
| case USES: |
| case EXPORTS: |
| case PROVIDES:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[162] = jj_gen; |
| break label_56; |
| } |
| st = ModuleStmt(); |
| statements = add(statements, st); |
| } |
| jj_consume_token(RBRACE); |
| return new ModuleDeclaration(range(begin, token()), modifier.annotations, name, open, statements); |
| } |
| |
| /* Rules for matching partial inputs. |
| These rules are needed to properly terminate them - |
| if we simply use the usual rules, they will ignore everything in the provider |
| after they matched their desired input, which will lead to unexpected behaviour |
| */ |
| final public |
| |
| BlockStmt BlockParseStart() throws ParseException {BlockStmt ret; |
| ret = Block(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public Statement BlockStatementParseStart() throws ParseException {Statement ret; |
| if (jj_2_58(3)) { |
| ret = BlockStatement(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case ENUM: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case STRICTFP: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case REQUIRES: |
| case TO: |
| case WITH: |
| case OPEN: |
| case OPENS: |
| case USES: |
| case MODULE: |
| case EXPORTS: |
| case PROVIDES: |
| case TRANSITIVE: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case AT: |
| case LT:{ |
| ret = ExplicitConstructorInvocation(); |
| break; |
| } |
| default: |
| jj_la1[163] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public ImportDeclaration ImportDeclarationParseStart() throws ParseException {ImportDeclaration ret; |
| ret = ImportDeclaration(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public Expression ExpressionParseStart() throws ParseException {Expression ret; |
| ret = Expression(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public AnnotationExpr AnnotationParseStart() throws ParseException {AnnotationExpr ret; |
| ret = Annotation(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public BodyDeclaration<?> AnnotationBodyDeclarationParseStart() throws ParseException {BodyDeclaration<?> ret; |
| ret = AnnotationBodyDeclaration(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public BodyDeclaration<?> ClassOrInterfaceBodyDeclarationParseStart() throws ParseException {BodyDeclaration<?> ret; |
| ret = ClassOrInterfaceBodyDeclaration(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public ClassOrInterfaceType ClassOrInterfaceTypeParseStart() throws ParseException {ClassOrInterfaceType ret; |
| ret = AnnotatedClassOrInterfaceType(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public Type ResultTypeParseStart() throws ParseException {NodeList<AnnotationExpr> annotations; Type ret; |
| annotations = Annotations(); |
| ret = ResultType(annotations); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public VariableDeclarationExpr VariableDeclarationExpressionParseStart() throws ParseException {VariableDeclarationExpr ret; |
| ret = VariableDeclarationExpression(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public ExplicitConstructorInvocationStmt ExplicitConstructorInvocationParseStart() throws ParseException {ExplicitConstructorInvocationStmt ret; |
| ret = ExplicitConstructorInvocation(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public Name NameParseStart() throws ParseException {Name ret; |
| ret = Name(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public SimpleName SimpleNameParseStart() throws ParseException {SimpleName ret; |
| ret = SimpleName(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public Parameter ParameterParseStart() throws ParseException {Parameter ret; |
| ret = Parameter(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| final public PackageDeclaration PackageDeclarationParseStart() throws ParseException {PackageDeclaration ret; |
| ret = PackageDeclaration(); |
| jj_consume_token(0); |
| return ret; |
| } |
| |
| private boolean jj_2_1(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_1()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(0, xla); } |
| } |
| |
| private boolean jj_2_2(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_2()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(1, xla); } |
| } |
| |
| private boolean jj_2_3(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_3()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(2, xla); } |
| } |
| |
| private boolean jj_2_4(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_4()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(3, xla); } |
| } |
| |
| private boolean jj_2_5(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_5()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(4, xla); } |
| } |
| |
| private boolean jj_2_6(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_6()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(5, xla); } |
| } |
| |
| private boolean jj_2_7(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_7()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(6, xla); } |
| } |
| |
| private boolean jj_2_8(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_8()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(7, xla); } |
| } |
| |
| private boolean jj_2_9(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_9()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(8, xla); } |
| } |
| |
| private boolean jj_2_10(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_10()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(9, xla); } |
| } |
| |
| private boolean jj_2_11(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_11()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(10, xla); } |
| } |
| |
| private boolean jj_2_12(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_12()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(11, xla); } |
| } |
| |
| private boolean jj_2_13(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_13()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(12, xla); } |
| } |
| |
| private boolean jj_2_14(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_14()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(13, xla); } |
| } |
| |
| private boolean jj_2_15(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_15()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(14, xla); } |
| } |
| |
| private boolean jj_2_16(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_16()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(15, xla); } |
| } |
| |
| private boolean jj_2_17(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_17()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(16, xla); } |
| } |
| |
| private boolean jj_2_18(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_18()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(17, xla); } |
| } |
| |
| private boolean jj_2_19(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_19()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(18, xla); } |
| } |
| |
| private boolean jj_2_20(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_20()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(19, xla); } |
| } |
| |
| private boolean jj_2_21(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_21()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(20, xla); } |
| } |
| |
| private boolean jj_2_22(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_22()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(21, xla); } |
| } |
| |
| private boolean jj_2_23(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_23()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(22, xla); } |
| } |
| |
| private boolean jj_2_24(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_24()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(23, xla); } |
| } |
| |
| private boolean jj_2_25(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_25()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(24, xla); } |
| } |
| |
| private boolean jj_2_26(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_26()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(25, xla); } |
| } |
| |
| private boolean jj_2_27(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_27()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(26, xla); } |
| } |
| |
| private boolean jj_2_28(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_28()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(27, xla); } |
| } |
| |
| private boolean jj_2_29(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_29()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(28, xla); } |
| } |
| |
| private boolean jj_2_30(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_30()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(29, xla); } |
| } |
| |
| private boolean jj_2_31(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_31()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(30, xla); } |
| } |
| |
| private boolean jj_2_32(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_32()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(31, xla); } |
| } |
| |
| private boolean jj_2_33(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_33()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(32, xla); } |
| } |
| |
| private boolean jj_2_34(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_34()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(33, xla); } |
| } |
| |
| private boolean jj_2_35(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_35()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(34, xla); } |
| } |
| |
| private boolean jj_2_36(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_36()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(35, xla); } |
| } |
| |
| private boolean jj_2_37(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_37()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(36, xla); } |
| } |
| |
| private boolean jj_2_38(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_38()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(37, xla); } |
| } |
| |
| private boolean jj_2_39(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_39()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(38, xla); } |
| } |
| |
| private boolean jj_2_40(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_40()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(39, xla); } |
| } |
| |
| private boolean jj_2_41(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_41()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(40, xla); } |
| } |
| |
| private boolean jj_2_42(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_42()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(41, xla); } |
| } |
| |
| private boolean jj_2_43(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_43()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(42, xla); } |
| } |
| |
| private boolean jj_2_44(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_44()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(43, xla); } |
| } |
| |
| private boolean jj_2_45(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_45()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(44, xla); } |
| } |
| |
| private boolean jj_2_46(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_46()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(45, xla); } |
| } |
| |
| private boolean jj_2_47(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_47()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(46, xla); } |
| } |
| |
| private boolean jj_2_48(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_48()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(47, xla); } |
| } |
| |
| private boolean jj_2_49(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_49()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(48, xla); } |
| } |
| |
| private boolean jj_2_50(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_50()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(49, xla); } |
| } |
| |
| private boolean jj_2_51(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_51()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(50, xla); } |
| } |
| |
| private boolean jj_2_52(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_52()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(51, xla); } |
| } |
| |
| private boolean jj_2_53(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_53()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(52, xla); } |
| } |
| |
| private boolean jj_2_54(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_54()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(53, xla); } |
| } |
| |
| private boolean jj_2_55(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_55()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(54, xla); } |
| } |
| |
| private boolean jj_2_56(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_56()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(55, xla); } |
| } |
| |
| private boolean jj_2_57(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_57()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(56, xla); } |
| } |
| |
| private boolean jj_2_58(int xla) |
| { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return (!jj_3_58()); } |
| catch(LookaheadSuccess ls) { return true; } |
| finally { jj_save(57, xla); } |
| } |
| |
| private boolean jj_3R_304() |
| { |
| if (jj_scan_token(EXTENDS)) return true; |
| if (jj_3R_306()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_408()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_296() |
| { |
| if (jj_3R_324()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_364()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_227() |
| { |
| if (jj_scan_token(INTERFACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_262() |
| { |
| if (jj_3R_305()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_286() |
| { |
| if (jj_scan_token(DO)) return true; |
| if (jj_3R_195()) return true; |
| if (jj_scan_token(WHILE)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_90()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_261() |
| { |
| if (jj_3R_304()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_260() |
| { |
| if (jj_3R_117()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_248() |
| { |
| if (jj_3R_296()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_348()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_194() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(19)) { |
| jj_scanpos = xsp; |
| if (jj_3R_227()) return true; |
| } |
| if (jj_3R_88()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_260()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_261()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_262()) jj_scanpos = xsp; |
| if (jj_3R_105()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_169() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_112()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_285() |
| { |
| if (jj_scan_token(WHILE)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_90()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_195()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_328() |
| { |
| if (jj_3R_74()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_200() |
| { |
| if (jj_3R_248()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_325()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_300() |
| { |
| if (jj_scan_token(HOOK)) return true; |
| if (jj_3R_90()) return true; |
| if (jj_scan_token(COLON)) return true; |
| if (jj_3R_149()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_149() |
| { |
| if (jj_3R_200()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_300()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_284() |
| { |
| if (jj_scan_token(IF)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_90()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_195()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_411()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_71() |
| { |
| if (jj_3R_115()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_70() |
| { |
| if (jj_scan_token(_DEFAULT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_69() |
| { |
| if (jj_scan_token(TRANSITIVE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_148() |
| { |
| if (jj_scan_token(ORASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_147() |
| { |
| if (jj_scan_token(XORASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_68() |
| { |
| if (jj_scan_token(STRICTFP)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_146() |
| { |
| if (jj_scan_token(ANDASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_145() |
| { |
| if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_431() |
| { |
| if (jj_scan_token(_DEFAULT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_67() |
| { |
| if (jj_scan_token(VOLATILE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_144() |
| { |
| if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_143() |
| { |
| if (jj_scan_token(LSHIFTASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_430() |
| { |
| if (jj_scan_token(CASE)) return true; |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_66() |
| { |
| if (jj_scan_token(TRANSIENT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_142() |
| { |
| if (jj_scan_token(MINUSASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_141() |
| { |
| if (jj_scan_token(PLUSASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_65() |
| { |
| if (jj_scan_token(NATIVE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_140() |
| { |
| if (jj_scan_token(REMASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_139() |
| { |
| if (jj_scan_token(SLASHASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_64() |
| { |
| if (jj_scan_token(SYNCHRONIZED)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_138() |
| { |
| if (jj_scan_token(STARASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_327() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_137() |
| { |
| if (jj_scan_token(ASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_63() |
| { |
| if (jj_scan_token(ABSTRACT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_62() |
| { |
| if (jj_scan_token(FINAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_424() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_430()) { |
| jj_scanpos = xsp; |
| if (jj_3R_431()) return true; |
| } |
| if (jj_scan_token(COLON)) return true; |
| if (jj_3R_179()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_61() |
| { |
| if (jj_scan_token(PRIVATE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_89() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_137()) { |
| jj_scanpos = xsp; |
| if (jj_3R_138()) { |
| jj_scanpos = xsp; |
| if (jj_3R_139()) { |
| jj_scanpos = xsp; |
| if (jj_3R_140()) { |
| jj_scanpos = xsp; |
| if (jj_3R_141()) { |
| jj_scanpos = xsp; |
| 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()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_302() |
| { |
| if (jj_scan_token(DOUBLECOLON)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_327()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_328()) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(42)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_60() |
| { |
| if (jj_scan_token(PROTECTED)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_59() |
| { |
| if (jj_scan_token(STATIC)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_58() |
| { |
| if (jj_scan_token(PUBLIC)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_410() |
| { |
| if (jj_3R_424()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_3() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| 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()) { |
| jj_scanpos = xsp; |
| if (jj_3R_62()) { |
| jj_scanpos = xsp; |
| if (jj_3R_63()) { |
| jj_scanpos = xsp; |
| if (jj_3R_64()) { |
| jj_scanpos = xsp; |
| if (jj_3R_65()) { |
| jj_scanpos = xsp; |
| 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()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_108() |
| { |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_3()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_283() |
| { |
| if (jj_scan_token(SWITCH)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_90()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_scan_token(LBRACE)) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_410()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_301() |
| { |
| if (jj_scan_token(ARROW)) return true; |
| if (jj_3R_326()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_361() |
| { |
| if (jj_3R_89()) return true; |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_360() |
| { |
| if (jj_scan_token(DECR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_24() |
| { |
| if (jj_3R_89()) return true; |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_359() |
| { |
| if (jj_scan_token(INCR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_343() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_359()) { |
| jj_scanpos = xsp; |
| if (jj_3R_360()) { |
| jj_scanpos = xsp; |
| if (jj_3R_361()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_255() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_24()) { |
| jj_scanpos = xsp; |
| if (jj_3R_301()) { |
| jj_scanpos = xsp; |
| if (jj_3R_302()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_318() |
| { |
| if (jj_3R_211()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_343()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_90() |
| { |
| if (jj_3R_149()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_255()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_317() |
| { |
| if (jj_3R_257()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_44() |
| { |
| if (jj_3R_110()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_282() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_44()) { |
| jj_scanpos = xsp; |
| if (jj_3R_317()) { |
| jj_scanpos = xsp; |
| if (jj_3R_318()) return true; |
| } |
| } |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_57() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_scan_token(PACKAGE)) return true; |
| if (jj_3R_80()) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_350() |
| { |
| if (jj_3R_121()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_349() |
| { |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_74() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(70)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(64)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(65)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(66)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(67)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(68)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(69)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(71)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(72)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(73)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(26)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(51)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(89)) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_326() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_349()) { |
| jj_scanpos = xsp; |
| if (jj_3R_350()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3_2() |
| { |
| if (jj_3R_57()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_23() |
| { |
| if (jj_scan_token(DOT)) return true; |
| if (jj_3R_86()) return true; |
| if (jj_3R_74()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_281() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_88() |
| { |
| if (jj_3R_74()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_1() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_125() |
| { |
| if (jj_scan_token(DOT)) return true; |
| if (jj_3R_86()) return true; |
| if (jj_3R_74()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_109() |
| { |
| if (jj_3R_108()) return true; |
| if (jj_3R_75()) return true; |
| if (jj_3R_112()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_169()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_80() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_3R_74()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_125()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_43() |
| { |
| if (jj_3R_109()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_42() |
| { |
| if (jj_3R_108()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(19)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(39)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_132() |
| { |
| if (jj_3R_195()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_167() |
| { |
| if (jj_3R_75()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_166() |
| { |
| if (jj_scan_token(VOID)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_131() |
| { |
| if (jj_3R_109()) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_130() |
| { |
| if (jj_3R_108()) return true; |
| if (jj_3R_194()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_102() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_166()) { |
| jj_scanpos = xsp; |
| if (jj_3R_167()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_336() |
| { |
| if (jj_scan_token(COLON)) return true; |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_84() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_130()) { |
| jj_scanpos = xsp; |
| if (jj_3R_131()) { |
| jj_scanpos = xsp; |
| if (jj_3R_132()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_160() |
| { |
| if (jj_scan_token(DOUBLE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_159() |
| { |
| if (jj_scan_token(FLOAT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_158() |
| { |
| if (jj_scan_token(LONG)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_157() |
| { |
| if (jj_scan_token(INT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_156() |
| { |
| if (jj_scan_token(SHORT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_155() |
| { |
| if (jj_scan_token(BYTE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_154() |
| { |
| if (jj_scan_token(CHAR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_358() |
| { |
| if (jj_scan_token(SUPER)) return true; |
| if (jj_3R_86()) return true; |
| if (jj_3R_85()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_226() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_199()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_153() |
| { |
| if (jj_scan_token(BOOLEAN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_357() |
| { |
| if (jj_scan_token(EXTENDS)) return true; |
| if (jj_3R_86()) return true; |
| if (jj_3R_85()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_342() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_357()) { |
| jj_scanpos = xsp; |
| if (jj_3R_358()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_97() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| 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()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_121() |
| { |
| if (jj_scan_token(LBRACE)) return true; |
| if (jj_3R_179()) return true; |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_295() |
| { |
| if (jj_scan_token(HOOK)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_342()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_107() |
| { |
| if (jj_3R_88()) return true; |
| if (jj_scan_token(COLON)) return true; |
| if (jj_3R_195()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_280() |
| { |
| if (jj_scan_token(ASSERT)) return true; |
| if (jj_3R_90()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_336()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_247() |
| { |
| if (jj_3R_295()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_246() |
| { |
| if (jj_3R_75()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_242() |
| { |
| if (jj_3R_293()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_199() |
| { |
| if (jj_3R_86()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_246()) { |
| jj_scanpos = xsp; |
| if (jj_3R_247()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_241() |
| { |
| if (jj_3R_292()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_240() |
| { |
| if (jj_3R_291()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_239() |
| { |
| if (jj_3R_290()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_238() |
| { |
| if (jj_3R_289()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_136() |
| { |
| if (jj_3R_199()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_226()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_237() |
| { |
| if (jj_3R_288()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_236() |
| { |
| if (jj_3R_287()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_87() |
| { |
| if (jj_scan_token(LT)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_136()) jj_scanpos = xsp; |
| if (jj_scan_token(GT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_235() |
| { |
| if (jj_3R_286()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_234() |
| { |
| if (jj_3R_285()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_233() |
| { |
| if (jj_3R_284()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_22() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_232() |
| { |
| if (jj_3R_283()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_231() |
| { |
| if (jj_3R_282()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_21() |
| { |
| if (jj_scan_token(DOT)) return true; |
| if (jj_3R_86()) return true; |
| if (jj_3R_88()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_22()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_230() |
| { |
| if (jj_3R_281()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_229() |
| { |
| if (jj_3R_121()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_393() |
| { |
| if (jj_scan_token(THROWS)) return true; |
| if (jj_3R_249()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_403()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_228() |
| { |
| if (jj_3R_280()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_19() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_scan_token(LBRACKET)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_41() |
| { |
| if (jj_3R_107()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_20() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_197() |
| { |
| if (jj_3R_88()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_20()) jj_scanpos = xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_21()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_195() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_41()) { |
| jj_scanpos = xsp; |
| if (jj_3R_228()) { |
| jj_scanpos = xsp; |
| if (jj_3R_229()) { |
| jj_scanpos = xsp; |
| if (jj_3R_230()) { |
| jj_scanpos = xsp; |
| if (jj_3R_231()) { |
| jj_scanpos = xsp; |
| if (jj_3R_232()) { |
| jj_scanpos = xsp; |
| if (jj_3R_233()) { |
| jj_scanpos = xsp; |
| if (jj_3R_234()) { |
| jj_scanpos = xsp; |
| if (jj_3R_235()) { |
| jj_scanpos = xsp; |
| if (jj_3R_236()) { |
| jj_scanpos = xsp; |
| if (jj_3R_237()) { |
| jj_scanpos = xsp; |
| if (jj_3R_238()) { |
| jj_scanpos = xsp; |
| if (jj_3R_239()) { |
| jj_scanpos = xsp; |
| if (jj_3R_240()) { |
| jj_scanpos = xsp; |
| if (jj_3R_241()) { |
| jj_scanpos = xsp; |
| if (jj_3R_242()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_18() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_scan_token(LBRACKET)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_198() |
| { |
| if (jj_3R_119()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_306() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_3R_197()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_39() |
| { |
| if (jj_3R_105()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_196() |
| { |
| if (jj_3R_119()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_106() |
| { |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_341() |
| { |
| if (jj_3R_180()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_40() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_scan_token(LBRACKET)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_106()) jj_scanpos = xsp; |
| if (jj_scan_token(RBRACKET)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_313() |
| { |
| Token xsp; |
| if (jj_3_40()) return true; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_40()) { jj_scanpos = xsp; break; } |
| } |
| xsp = jj_scanpos; |
| if (jj_3R_341()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_308() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_316() |
| { |
| if (jj_3R_183()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_39()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_315() |
| { |
| if (jj_3R_313()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_119() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_scan_token(LBRACKET)) return true; |
| if (jj_scan_token(RBRACKET)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_314() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_279() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_314()) jj_scanpos = xsp; |
| if (jj_3R_306()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_315()) { |
| jj_scanpos = xsp; |
| if (jj_3R_316()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_278() |
| { |
| if (jj_3R_97()) return true; |
| if (jj_3R_313()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_134() |
| { |
| if (jj_3R_197()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_198()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_133() |
| { |
| if (jj_3R_97()) return true; |
| Token xsp; |
| if (jj_3R_196()) return true; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_196()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_85() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_133()) { |
| jj_scanpos = xsp; |
| if (jj_3R_134()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_222() |
| { |
| if (jj_scan_token(NEW)) return true; |
| if (jj_3R_86()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_278()) { |
| jj_scanpos = xsp; |
| if (jj_3R_279()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_118() |
| { |
| if (jj_3R_97()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_17() |
| { |
| if (jj_3R_85()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_58() |
| { |
| if (jj_3R_84()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_75() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_17()) { |
| jj_scanpos = xsp; |
| if (jj_3R_118()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_264() |
| { |
| if (jj_3R_90()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_308()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_214() |
| { |
| if (jj_3R_264()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_120() |
| { |
| if (jj_scan_token(STATIC)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_183() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_214()) jj_scanpos = xsp; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_77() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_120()) jj_scanpos = xsp; |
| if (jj_3R_121()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_16() |
| { |
| if (jj_3R_84()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_179() |
| { |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_16()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_14() |
| { |
| if (jj_3R_82()) return true; |
| if (jj_scan_token(DOT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_340() |
| { |
| if (jj_scan_token(FALSE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_310() |
| { |
| if (jj_scan_token(NULL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_339() |
| { |
| if (jj_scan_token(TRUE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_441() |
| { |
| if (jj_3R_442()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_83() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_185() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_57() |
| { |
| if (jj_scan_token(REQUIRES)) return true; |
| if (jj_scan_token(TRANSITIVE)) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_15() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_83()) jj_scanpos = xsp; |
| if (jj_scan_token(THIS)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_184() |
| { |
| if (jj_3R_82()) return true; |
| if (jj_scan_token(DOT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_309() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_339()) { |
| jj_scanpos = xsp; |
| if (jj_3R_340()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_127() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_184()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_185()) jj_scanpos = xsp; |
| if (jj_scan_token(SUPER)) return true; |
| if (jj_3R_183()) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_271() |
| { |
| if (jj_3R_310()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_182() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_270() |
| { |
| if (jj_3R_309()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_126() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_182()) jj_scanpos = xsp; |
| if (jj_scan_token(THIS)) return true; |
| if (jj_3R_183()) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_269() |
| { |
| if (jj_scan_token(STRING_LITERAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_268() |
| { |
| if (jj_scan_token(CHARACTER_LITERAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_81() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_126()) { |
| jj_scanpos = xsp; |
| if (jj_3R_127()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_267() |
| { |
| if (jj_scan_token(FLOATING_POINT_LITERAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_266() |
| { |
| if (jj_scan_token(LONG_LITERAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_13() |
| { |
| if (jj_3R_81()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_265() |
| { |
| if (jj_scan_token(INTEGER_LITERAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_104() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_164() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_scan_token(ELLIPSIS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_38() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_104()) jj_scanpos = xsp; |
| if (jj_3R_74()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_394() |
| { |
| if (jj_3R_81()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_215() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_265()) { |
| jj_scanpos = xsp; |
| if (jj_3R_266()) { |
| jj_scanpos = xsp; |
| if (jj_3R_267()) { |
| jj_scanpos = xsp; |
| if (jj_3R_268()) { |
| jj_scanpos = xsp; |
| if (jj_3R_269()) { |
| jj_scanpos = xsp; |
| if (jj_3R_270()) { |
| jj_scanpos = xsp; |
| if (jj_3R_271()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_442() |
| { |
| if (jj_scan_token(_DEFAULT)) return true; |
| if (jj_3R_114()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_163() |
| { |
| if (jj_scan_token(LBRACKET)) return true; |
| if (jj_3R_90()) return true; |
| if (jj_scan_token(RBRACKET)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_254() |
| { |
| if (jj_3R_183()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_403() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_249()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_224() |
| { |
| if (jj_3R_74()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_253() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_365() |
| { |
| if (jj_3R_117()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_353() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_365()) jj_scanpos = xsp; |
| if (jj_3R_88()) return true; |
| if (jj_3R_392()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_393()) jj_scanpos = xsp; |
| if (jj_scan_token(LBRACE)) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_394()) jj_scanpos = xsp; |
| if (jj_3R_179()) return true; |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_205() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_253()) jj_scanpos = xsp; |
| if (jj_3R_88()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_254()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_204() |
| { |
| if (jj_3R_222()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_12() |
| { |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_56() |
| { |
| if (jj_scan_token(ENUM)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_203() |
| { |
| if (jj_scan_token(THIS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_439() |
| { |
| if (jj_3R_75()) return true; |
| if (jj_3R_88()) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_441()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_55() |
| { |
| if (jj_3R_75()) return true; |
| if (jj_3R_74()) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_438() |
| { |
| if (jj_3R_354()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_437() |
| { |
| if (jj_3R_352()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_436() |
| { |
| if (jj_3R_351()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_181() |
| { |
| if (jj_3R_80()) return true; |
| if (jj_scan_token(DOT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_162() |
| { |
| if (jj_scan_token(DOT)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_203()) { |
| jj_scanpos = xsp; |
| if (jj_3R_204()) { |
| jj_scanpos = xsp; |
| if (jj_3R_205()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_435() |
| { |
| if (jj_3R_194()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_124() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_181()) jj_scanpos = xsp; |
| if (jj_3R_86()) return true; |
| if (jj_scan_token(THIS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_434() |
| { |
| if (jj_3R_439()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_54() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_114()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_99() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_162()) { |
| jj_scanpos = xsp; |
| if (jj_3R_163()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_311() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_100()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_223() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_79() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_3R_75()) return true; |
| if (jj_3R_124()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_161() |
| { |
| if (jj_scan_token(DOT)) return true; |
| if (jj_scan_token(SUPER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_429() |
| { |
| if (jj_3R_108()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_434()) { |
| jj_scanpos = xsp; |
| if (jj_3R_435()) { |
| jj_scanpos = xsp; |
| if (jj_3R_436()) { |
| jj_scanpos = xsp; |
| if (jj_3R_437()) { |
| jj_scanpos = xsp; |
| if (jj_3R_438()) return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_37() |
| { |
| if (jj_3R_99()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_417() |
| { |
| if (jj_3R_429()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_401() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_417()) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(98)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_275() |
| { |
| if (jj_3R_74()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_98() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_37()) { |
| jj_scanpos = xsp; |
| if (jj_3R_161()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_225() |
| { |
| if (jj_3R_183()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_391() |
| { |
| if (jj_scan_token(LBRACE)) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_401()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_193() |
| { |
| if (jj_3R_88()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_225()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_100() |
| { |
| if (jj_3R_108()) return true; |
| if (jj_3R_75()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_164()) jj_scanpos = xsp; |
| if (jj_3R_101()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_36() |
| { |
| if (jj_3R_103()) return true; |
| if (jj_scan_token(DOUBLECOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_35() |
| { |
| if (jj_3R_102()) return true; |
| if (jj_scan_token(DOT)) return true; |
| if (jj_scan_token(CLASS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_312() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_101()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_352() |
| { |
| if (jj_scan_token(AT)) return true; |
| if (jj_scan_token(INTERFACE)) return true; |
| if (jj_3R_88()) return true; |
| if (jj_3R_391()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_192() |
| { |
| if (jj_3R_103()) return true; |
| if (jj_scan_token(DOUBLECOLON)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_223()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_224()) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(42)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3_34() |
| { |
| if (jj_3R_101()) return true; |
| if (jj_scan_token(COMMA)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_277() |
| { |
| if (jj_3R_101()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_312()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_191() |
| { |
| if (jj_3R_102()) return true; |
| if (jj_scan_token(DOT)) return true; |
| if (jj_scan_token(CLASS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_33() |
| { |
| if (jj_3R_100()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_190() |
| { |
| if (jj_3R_222()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_346() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_345()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_221() |
| { |
| if (jj_3R_90()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_362() |
| { |
| if (jj_3R_114()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_54()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_274() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_10() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_78()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_220() |
| { |
| if (jj_3R_277()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_276() |
| { |
| if (jj_3R_100()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_311()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_218() |
| { |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_11() |
| { |
| if (jj_3R_79()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_219() |
| { |
| if (jj_3R_276()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_212() |
| { |
| if (jj_scan_token(LBRACE)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_362()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(99)) jj_scanpos = xsp; |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_217() |
| { |
| if (jj_scan_token(DOUBLECOLON)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_274()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_275()) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(42)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_420() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_100()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_419() |
| { |
| if (jj_3R_100()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_189() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_218()) { |
| jj_scanpos = xsp; |
| if (jj_3R_219()) { |
| jj_scanpos = xsp; |
| if (jj_3R_220()) { |
| jj_scanpos = xsp; |
| if (jj_3R_221()) return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_176() |
| { |
| if (jj_3R_149()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_53() |
| { |
| if (jj_scan_token(AT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_175() |
| { |
| if (jj_3R_212()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_396() |
| { |
| if (jj_3R_119()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_418() |
| { |
| if (jj_3R_79()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_402() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_418()) { |
| jj_scanpos = xsp; |
| if (jj_3R_419()) return true; |
| } |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_420()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_273() |
| { |
| if (jj_3R_183()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_174() |
| { |
| if (jj_3R_115()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_392() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_402()) jj_scanpos = xsp; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_216() |
| { |
| if (jj_scan_token(DOT)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_272()) jj_scanpos = xsp; |
| if (jj_3R_88()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_273()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_272() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_114() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_174()) { |
| jj_scanpos = xsp; |
| if (jj_3R_175()) { |
| jj_scanpos = xsp; |
| if (jj_3R_176()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_32() |
| { |
| if (jj_3R_99()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_188() |
| { |
| if (jj_scan_token(SUPER)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_216()) { |
| jj_scanpos = xsp; |
| if (jj_3R_217()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_187() |
| { |
| if (jj_scan_token(THIS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_345() |
| { |
| if (jj_3R_88()) return true; |
| if (jj_scan_token(ASSIGN)) return true; |
| if (jj_3R_114()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_186() |
| { |
| if (jj_3R_215()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_103() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_3R_75()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_129() |
| { |
| if (jj_3R_99()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_113() |
| { |
| if (jj_3R_74()) return true; |
| if (jj_scan_token(ASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_128() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_186()) { |
| jj_scanpos = xsp; |
| if (jj_3R_187()) { |
| jj_scanpos = xsp; |
| if (jj_3R_188()) { |
| jj_scanpos = xsp; |
| if (jj_3R_189()) { |
| jj_scanpos = xsp; |
| if (jj_3R_190()) { |
| jj_scanpos = xsp; |
| if (jj_3R_191()) { |
| jj_scanpos = xsp; |
| if (jj_3R_192()) { |
| jj_scanpos = xsp; |
| if (jj_3R_193()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_52() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_323() |
| { |
| if (jj_3R_345()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_346()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_31() |
| { |
| if (jj_3R_98()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_249() |
| { |
| if (jj_3R_86()) return true; |
| if (jj_3R_85()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_51() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_113()) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(93)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_245() |
| { |
| return false; |
| } |
| |
| private boolean jj_3R_294() |
| { |
| if (jj_3R_323()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_244() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_114()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_404() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_249()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_398() |
| { |
| if (jj_3R_121()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_243() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_294()) jj_scanpos = xsp; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_397() |
| { |
| if (jj_scan_token(THROWS)) return true; |
| if (jj_3R_249()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_404()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_82() |
| { |
| if (jj_3R_128()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_129()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_366() |
| { |
| if (jj_3R_117()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_115() |
| { |
| if (jj_scan_token(AT)) return true; |
| if (jj_3R_80()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_243()) { |
| jj_scanpos = xsp; |
| if (jj_3R_244()) { |
| jj_scanpos = xsp; |
| if (jj_3R_245()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_335() |
| { |
| if (jj_3R_78()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_10()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_355() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_366()) jj_scanpos = xsp; |
| if (jj_3R_86()) return true; |
| if (jj_3R_102()) return true; |
| if (jj_3R_88()) return true; |
| if (jj_3R_392()) return true; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_396()) { jj_scanpos = xsp; break; } |
| } |
| xsp = jj_scanpos; |
| if (jj_3R_397()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_398()) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(98)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3_50() |
| { |
| if (jj_scan_token(AT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_211() |
| { |
| if (jj_3R_128()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_31()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_165() |
| { |
| if (jj_3R_119()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_135() |
| { |
| if (jj_3R_115()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_86() |
| { |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_135()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_150() |
| { |
| return false; |
| } |
| |
| private boolean jj_3R_201() |
| { |
| if (jj_scan_token(BIT_AND)) return true; |
| if (jj_3R_249()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_48() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| if (jj_3R_111()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_152() |
| { |
| if (jj_3R_85()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_201()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_202()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_180() |
| { |
| if (jj_scan_token(LBRACE)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_335()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(99)) jj_scanpos = xsp; |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_30() |
| { |
| if (jj_3R_97()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_170()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_151() |
| { |
| return false; |
| } |
| |
| private boolean jj_3R_123() |
| { |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_92() |
| { |
| jj_lookingAhead = true; |
| jj_semLA = getToken(1).kind == GT && |
| getToken(1).realKind == RSIGNEDSHIFT; |
| jj_lookingAhead = false; |
| if (!jj_semLA || jj_3R_150()) return true; |
| if (jj_scan_token(GT)) return true; |
| if (jj_scan_token(GT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_122() |
| { |
| if (jj_3R_180()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_173() |
| { |
| if (jj_scan_token(ASSIGN)) return true; |
| if (jj_3R_78()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_94() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_86()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_30()) { |
| jj_scanpos = xsp; |
| if (jj_3R_152()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_93() |
| { |
| jj_lookingAhead = true; |
| jj_semLA = getToken(1).kind == GT && |
| getToken(1).realKind == RUNSIGNEDSHIFT; |
| jj_lookingAhead = false; |
| if (!jj_semLA || jj_3R_151()) return true; |
| if (jj_scan_token(GT)) return true; |
| if (jj_scan_token(GT)) return true; |
| if (jj_scan_token(GT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_78() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_122()) { |
| jj_scanpos = xsp; |
| if (jj_3R_123()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3_49() |
| { |
| if (jj_3R_108()) return true; |
| if (jj_3R_75()) return true; |
| if (jj_3R_112()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_172() |
| { |
| if (jj_3R_211()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_96() |
| { |
| if (jj_scan_token(DECR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_29() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_95()) { |
| jj_scanpos = xsp; |
| if (jj_3R_96()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_95() |
| { |
| if (jj_scan_token(INCR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_28() |
| { |
| if (jj_3R_94()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_101() |
| { |
| if (jj_3R_88()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_165()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_76() |
| { |
| if (jj_3R_119()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_171() |
| { |
| if (jj_3R_109()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_111() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_171()) { |
| jj_scanpos = xsp; |
| if (jj_3R_172()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_299() |
| { |
| if (jj_3R_211()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_29()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_251() |
| { |
| if (jj_3R_94()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_368() |
| { |
| if (jj_3R_111()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_48()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_298() |
| { |
| if (jj_scan_token(BANG)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_252() |
| { |
| if (jj_3R_299()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_297() |
| { |
| if (jj_scan_token(TILDE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_112() |
| { |
| if (jj_3R_101()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_173()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_250() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_297()) { |
| jj_scanpos = xsp; |
| if (jj_3R_298()) return true; |
| } |
| if (jj_3R_170()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_395() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_112()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_73() |
| { |
| if (jj_3R_117()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_8() |
| { |
| if (jj_3R_75()) return true; |
| if (jj_3R_74()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_76()) { jj_scanpos = xsp; break; } |
| } |
| xsp = jj_scanpos; |
| if (jj_scan_token(99)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(102)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(98)) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_202() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_250()) { |
| jj_scanpos = xsp; |
| if (jj_3R_251()) { |
| jj_scanpos = xsp; |
| if (jj_3R_252()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_428() |
| { |
| if (jj_scan_token(FINALLY)) return true; |
| if (jj_3R_121()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_413() |
| { |
| if (jj_scan_token(FINALLY)) return true; |
| if (jj_3R_121()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_7() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_73()) jj_scanpos = xsp; |
| if (jj_3R_74()) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_47() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_354() |
| { |
| if (jj_3R_75()) return true; |
| if (jj_3R_112()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_395()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_344() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_368()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_47()) jj_scanpos = xsp; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_6() |
| { |
| if (jj_scan_token(AT)) return true; |
| if (jj_scan_token(INTERFACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_5() |
| { |
| if (jj_scan_token(ENUM)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_334() |
| { |
| if (jj_3R_355()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_433() |
| { |
| if (jj_scan_token(BIT_OR)) return true; |
| if (jj_3R_249()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_333() |
| { |
| if (jj_3R_354()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_257() |
| { |
| if (jj_scan_token(DECR)) return true; |
| if (jj_3R_170()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_332() |
| { |
| if (jj_3R_353()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_427() |
| { |
| if (jj_scan_token(CATCH)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_108()) return true; |
| if (jj_3R_85()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_433()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_3R_101()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_121()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_331() |
| { |
| if (jj_3R_352()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_330() |
| { |
| if (jj_3R_351()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_329() |
| { |
| if (jj_3R_194()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_110() |
| { |
| if (jj_scan_token(INCR)) return true; |
| if (jj_3R_170()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_303() |
| { |
| if (jj_3R_108()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_329()) { |
| jj_scanpos = xsp; |
| if (jj_3R_330()) { |
| jj_scanpos = xsp; |
| if (jj_3R_331()) { |
| jj_scanpos = xsp; |
| if (jj_3R_332()) { |
| jj_scanpos = xsp; |
| if (jj_3R_333()) { |
| jj_scanpos = xsp; |
| if (jj_3R_334()) return true; |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_210() |
| { |
| if (jj_3R_202()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_9() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_259() |
| { |
| if (jj_scan_token(MINUS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_258() |
| { |
| if (jj_scan_token(PLUS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_213() |
| { |
| if (jj_3R_263()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_412() |
| { |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_427()) { jj_scanpos = xsp; break; } |
| } |
| xsp = jj_scanpos; |
| if (jj_3R_428()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_209() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_258()) { |
| jj_scanpos = xsp; |
| if (jj_3R_259()) return true; |
| } |
| if (jj_3R_170()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_208() |
| { |
| if (jj_3R_257()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_207() |
| { |
| if (jj_3R_110()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_256() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_9()) { |
| jj_scanpos = xsp; |
| if (jj_3R_303()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_322() |
| { |
| if (jj_3R_344()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_293() |
| { |
| if (jj_scan_token(TRY)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_322()) jj_scanpos = xsp; |
| if (jj_3R_121()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_412()) { |
| jj_scanpos = xsp; |
| if (jj_3R_413()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_168() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_206()) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(98)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_206() |
| { |
| if (jj_3R_256()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_170() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_207()) { |
| jj_scanpos = xsp; |
| if (jj_3R_208()) { |
| jj_scanpos = xsp; |
| if (jj_3R_209()) { |
| jj_scanpos = xsp; |
| if (jj_3R_210()) return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_423() |
| { |
| if (jj_scan_token(REM)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_105() |
| { |
| if (jj_scan_token(LBRACE)) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_168()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_422() |
| { |
| if (jj_scan_token(SLASH)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_421() |
| { |
| if (jj_scan_token(STAR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_405() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_421()) { |
| jj_scanpos = xsp; |
| if (jj_3R_422()) { |
| jj_scanpos = xsp; |
| if (jj_3R_423()) return true; |
| } |
| } |
| if (jj_3R_170()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_321() |
| { |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_307() |
| { |
| if (jj_scan_token(BIT_AND)) return true; |
| if (jj_3R_306()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_382() |
| { |
| if (jj_3R_170()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_405()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_263() |
| { |
| if (jj_scan_token(EXTENDS)) return true; |
| if (jj_3R_306()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_307()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_292() |
| { |
| if (jj_scan_token(SYNCHRONIZED)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_90()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_121()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_320() |
| { |
| if (jj_3R_88()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_407() |
| { |
| if (jj_scan_token(MINUS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_406() |
| { |
| if (jj_scan_token(PLUS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_399() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_406()) { |
| jj_scanpos = xsp; |
| if (jj_3R_407()) return true; |
| } |
| if (jj_3R_382()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_4() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_72()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_177() |
| { |
| if (jj_3R_88()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_213()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_291() |
| { |
| if (jj_scan_token(THROW)) return true; |
| if (jj_3R_90()) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_378() |
| { |
| if (jj_3R_382()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_399()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_319() |
| { |
| if (jj_3R_88()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_415() |
| { |
| if (jj_3R_105()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_178() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_86()) return true; |
| if (jj_3R_177()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_27() |
| { |
| if (jj_3R_93()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_26() |
| { |
| if (jj_3R_92()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_440() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_290() |
| { |
| if (jj_scan_token(RETURN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_321()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_91() |
| { |
| if (jj_scan_token(LSHIFT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_25() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_91()) { |
| jj_scanpos = xsp; |
| if (jj_3_26()) { |
| jj_scanpos = xsp; |
| if (jj_3_27()) return true; |
| } |
| } |
| if (jj_3R_378()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_117() |
| { |
| if (jj_scan_token(LT)) return true; |
| if (jj_3R_86()) return true; |
| if (jj_3R_177()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_178()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(GT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_379() |
| { |
| if (jj_scan_token(INSTANCEOF)) return true; |
| if (jj_3R_249()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_376() |
| { |
| if (jj_3R_378()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_25()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_289() |
| { |
| if (jj_scan_token(CONTINUE)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_320()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_387() |
| { |
| if (jj_scan_token(GE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_386() |
| { |
| if (jj_scan_token(LE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_426() |
| { |
| if (jj_3R_432()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_385() |
| { |
| if (jj_scan_token(GT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_384() |
| { |
| if (jj_scan_token(LT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_414() |
| { |
| if (jj_3R_183()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_383() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_384()) { |
| jj_scanpos = xsp; |
| if (jj_3R_385()) { |
| jj_scanpos = xsp; |
| if (jj_3R_386()) { |
| jj_scanpos = xsp; |
| if (jj_3R_387()) return true; |
| } |
| } |
| } |
| if (jj_3R_376()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_288() |
| { |
| if (jj_scan_token(BREAK)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_319()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_116() |
| { |
| if (jj_3R_115()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_72() |
| { |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_116()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_3R_88()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_414()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_415()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_373() |
| { |
| if (jj_3R_376()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_383()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_432() |
| { |
| if (jj_3R_375()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_416() |
| { |
| if (jj_3R_256()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_411() |
| { |
| if (jj_scan_token(ELSE)) return true; |
| if (jj_3R_195()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_400() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_416()) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(98)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3_46() |
| { |
| if (jj_3R_108()) return true; |
| if (jj_3R_75()) return true; |
| if (jj_3R_74()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_374() |
| { |
| if (jj_scan_token(BIT_AND)) return true; |
| if (jj_3R_363()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_369() |
| { |
| if (jj_3R_373()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_379()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_390() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_400()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_375() |
| { |
| if (jj_3R_90()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_440()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_372() |
| { |
| if (jj_3R_375()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_425() |
| { |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_389() |
| { |
| if (jj_3R_72()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_4()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_371() |
| { |
| if (jj_3R_109()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_388() |
| { |
| if (jj_3R_305()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_381() |
| { |
| if (jj_scan_token(NE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_380() |
| { |
| if (jj_scan_token(EQ)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_377() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_380()) { |
| jj_scanpos = xsp; |
| if (jj_3R_381()) return true; |
| } |
| if (jj_3R_369()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_370() |
| { |
| if (jj_scan_token(XOR)) return true; |
| if (jj_3R_347()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_351() |
| { |
| if (jj_scan_token(ENUM)) return true; |
| if (jj_3R_88()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_388()) jj_scanpos = xsp; |
| if (jj_scan_token(LBRACE)) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_389()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(99)) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_390()) jj_scanpos = xsp; |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_367() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_371()) { |
| jj_scanpos = xsp; |
| if (jj_3R_372()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_364() |
| { |
| if (jj_scan_token(BIT_OR)) return true; |
| if (jj_3R_324()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_363() |
| { |
| if (jj_3R_369()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_377()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_45() |
| { |
| if (jj_3R_109()) return true; |
| if (jj_scan_token(COLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_348() |
| { |
| if (jj_scan_token(SC_AND)) return true; |
| if (jj_3R_296()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_409() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_306()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_347() |
| { |
| if (jj_3R_363()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_374()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_356() |
| { |
| if (jj_3R_367()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_305() |
| { |
| if (jj_scan_token(IMPLEMENTS)) return true; |
| if (jj_3R_306()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_409()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_338() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_356()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_425()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_426()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_325() |
| { |
| if (jj_scan_token(SC_OR)) return true; |
| if (jj_3R_248()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_337() |
| { |
| if (jj_3R_109()) return true; |
| if (jj_scan_token(COLON)) return true; |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_324() |
| { |
| if (jj_3R_347()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_370()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_408() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_306()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_287() |
| { |
| if (jj_scan_token(FOR)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_337()) { |
| jj_scanpos = xsp; |
| if (jj_3R_338()) return true; |
| } |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_195()) return true; |
| return false; |
| } |
| |
| /** Generated Token Manager. */ |
| public GeneratedJavaParserTokenManager token_source; |
| SimpleCharStream jj_input_stream; |
| /** Current token. */ |
| public Token token; |
| /** Next token. */ |
| public Token jj_nt; |
| private int jj_ntk; |
| private Token jj_scanpos, jj_lastpos; |
| private int jj_la; |
| /** Whether we are looking ahead. */ |
| private boolean jj_lookingAhead = false; |
| private boolean jj_semLA; |
| private int jj_gen; |
| final private int[] jj_la1 = new int[164]; |
| static private int[] jj_la1_0; |
| static private int[] jj_la1_1; |
| static private int[] jj_la1_2; |
| static private int[] jj_la1_3; |
| static private int[] jj_la1_4; |
| static { |
| jj_la1_init_0(); |
| jj_la1_init_1(); |
| jj_la1_init_2(); |
| jj_la1_init_3(); |
| jj_la1_init_4(); |
| } |
| private static void jj_la1_init_0() { |
| jj_la1_0 = new int[] {0x24480800,0x4080000,0x24480800,0x1,0x0,0x0,0x20400800,0x80000,0x0,0x8000000,0x0,0x0,0x0,0x0,0x4000000,0x0,0xa54ca800,0xa54ca800,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0xa54ca800,0xa54ca800,0x80000,0x8504a000,0xa54ca800,0x0,0x0,0x0,0x9504a000,0x9504a000,0x0,0x0,0x0,0x0,0x0,0x0,0xa544a800,0x0,0xa544a800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,0x0,0x8104a000,0x8504a000,0x8504a000,0x0,0x8504a000,0x8504a000,0x8000000,0x8000000,0x8104a000,0x8504a000,0x4000000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,0x0,0x0,0x9504a000,0x0,0x0,0x8504a000,0x0,0x0,0x0,0x4000000,0x0,0x0,0x9504a000,0x0,0x4000000,0x0,0x10000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x9504a000,0x0,0x0,0x0,0x8504a000,0x9504a000,0x0,0x95a4f000,0x0,0x95a4f000,0x0,0x9504a000,0x0,0x0,0x9504a000,0x410000,0x410000,0x2000000,0xb544a800,0x9504a000,0x9504a000,0xb544a800,0x9504a000,0x0,0x4000000,0x4000000,0x9504a000,0x0,0x20000,0x0,0x40000000,0x9504a000,0x4000000,0x0,0x9504a000,0x9504a000,0x0,0xa54ca800,0xa54ca800,0x80000,0x8504a000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,}; |
| } |
| private static void jj_la1_init_1() { |
| jj_la1_1 = new int[] {0x444ce290,0x80,0x444ce290,0x0,0x40000,0x0,0x444ce200,0x80,0x0,0x0,0x8,0x0,0x0,0x8,0x80000,0x0,0x644ee3c0,0x644ee3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x644ee3c0,0x644ee3c0,0x80,0x200a0140,0x644ee3c0,0x0,0x0,0x0,0x289a0d40,0x289a0d40,0x0,0x0,0x0,0x0,0x2000000,0x0,0x444ee340,0x0,0x444ee340,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x289a0d40,0x40000,0x20140,0xa0140,0xa0140,0x0,0xa0140,0xa0140,0x100000,0x100000,0x20140,0x200a0140,0x80000,0x0,0x80400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x289a0d40,0x0,0x0,0x289a0d40,0x0,0x0,0xa0140,0x0,0x0,0x0,0x80400,0x0,0x0,0x289a0d40,0x0,0x80400,0x0,0x8900c00,0x80000,0x0,0x0,0x0,0x800400,0x0,0x8000800,0x8000000,0x289a0d40,0x0,0x0,0x0,0xa0140,0x289a0d40,0x0,0xb9fb0d45,0x0,0xb9fb0d45,0x0,0x289a0d40,0x0,0x0,0x289a0d40,0x0,0x0,0x0,0x6cdeef40,0x289a0d40,0x289a0d40,0x6cdeef40,0x289a0d40,0x0,0x80000,0x80000,0x289a0d40,0x0,0x0,0x0,0x0,0x289a0d40,0x80000,0x0,0x289a0d40,0x289a0d40,0x0,0x444ee3c0,0x444ee3c0,0x80,0xa0140,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x289a0d40,}; |
| } |
| private static void jj_la1_init_2() { |
| jj_la1_2 = new int[] {0x248,0x48,0x248,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20003ff,0x0,0x420003ff,0x420003ff,0x0,0x0,0x10000000,0x40000000,0x0,0x0,0x0,0x420003ff,0x420003ff,0x0,0x20003ff,0x20003ff,0x0,0x0,0x0,0x53810fff,0x53810fff,0x0,0x0,0x0,0x0,0x0,0x40000000,0x20003ff,0x0,0x20003ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x13810fff,0x0,0x0,0x20003ff,0x20003ff,0x0,0x20003ff,0x20003ff,0x0,0x0,0x0,0x20003ff,0x20003ff,0x0,0x20003ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x13810fff,0x0,0x0,0x13810fff,0x0,0x0,0x20003ff,0x0,0x10000000,0x0,0x20003ff,0x0,0x20000000,0x13810fff,0x0,0x20003ff,0x10000000,0x11810c00,0x20003ff,0x0,0x0,0x10000000,0x0,0x0,0x1810c00,0x0,0x13810fff,0x0,0x0,0x10000000,0x20003ff,0x13810fff,0x40000000,0x53810fff,0x0,0x53810fff,0x0,0x53810fff,0x0,0x0,0x13810fff,0x0,0x0,0x0,0x13810fff,0x13810fff,0x13810fff,0x13810fff,0x13810fff,0x0,0x20003ff,0x20003ff,0x13810fff,0x10000000,0x0,0x0,0x0,0x13810fff,0x20003ff,0x0,0x53810fff,0x53810fff,0x0,0x20003ff,0x20003ff,0x0,0x20003ff,0x0,0x0,0x2,0x0,0x2,0x0,0x1b1,0x8,0x1b1,0x13810fff,}; |
| } |
| private static void jj_la1_init_3() { |
| jj_la1_3 = new int[] {0x24,0x24,0x24,0x0,0x0,0x10,0x20,0x0,0x80,0x0,0x0,0x8,0x8,0x0,0x20,0x8,0xa4,0xa4,0x4,0x20,0x0,0x0,0x8,0x0,0x1000000,0xa4,0xa4,0x0,0xa0,0xa0,0x8,0x40,0x21,0x3c0320,0x3c0320,0x8,0x80,0x21,0x8,0x0,0x4,0x20,0x8,0x20,0x8,0x8,0x20,0x80,0x8,0x0,0x80,0x80,0xa0,0x0,0x0,0x0,0x20,0x8,0x420,0x400,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0xe0000040,0xe0000040,0x400,0x10000,0x20000,0x2000000,0x4000000,0x1000000,0x9000,0x9000,0x0,0x6080,0x6080,0x10000000,0x300000,0x300000,0x8c00000,0x8c00000,0x300000,0x3c0320,0x300,0x300,0x20,0xc0000,0x1000000,0x0,0x80,0x0,0x80,0x0,0x10,0x0,0x3c0320,0x80,0x0,0x0,0x0,0x0,0x10,0x80,0x0,0x0,0x11,0x0,0x0,0x3c0320,0x8,0x80,0x21,0xa0,0x3c0320,0x0,0xc0024,0x800,0xc0024,0x8,0x3c0320,0xe00c0040,0xe00c0040,0x80020,0x0,0x0,0x0,0x3c0320,0x3c0320,0x3c0320,0x3c0324,0x3c0320,0x8,0x0,0x0,0x3c0320,0x0,0x0,0x2000000,0x0,0x20,0x0,0x8,0x3c0320,0x3c0320,0x8,0x24,0x24,0x0,0x20,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x0,0x0,0xa0,}; |
| } |
| private static void jj_la1_init_4() { |
| jj_la1_4 = new int[] {0x0,0x0,0x0,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x6ff,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x2000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,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,0xff,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; |
| } |
| final private JJCalls[] jj_2_rtns = new JJCalls[58]; |
| private boolean jj_rescan = false; |
| private int jj_gc = 0; |
| |
| /** Constructor. */ |
| public GeneratedJavaParser(Provider stream) { |
| jj_input_stream = new SimpleCharStream(stream, 1, 1); |
| token_source = new GeneratedJavaParserTokenManager(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 164; i++) jj_la1[i] = -1; |
| for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); |
| } |
| |
| /** Constructor. */ |
| public GeneratedJavaParser(String dsl) throws ParseException, TokenMgrException { |
| this(new StringProvider(dsl)); |
| } |
| |
| public void ReInit(String s) { |
| ReInit(new StringProvider(s)); |
| } |
| /** Reinitialise. */ |
| public void ReInit(Provider stream) { |
| if (jj_input_stream == null) { |
| jj_input_stream = new SimpleCharStream(stream, 1, 1); |
| } else { |
| jj_input_stream.ReInit(stream, 1, 1); |
| } |
| if (token_source == null) { |
| token_source = new GeneratedJavaParserTokenManager(jj_input_stream); |
| } |
| |
| token_source.ReInit(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 164; i++) jj_la1[i] = -1; |
| for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); |
| } |
| |
| /** Constructor with generated Token Manager. */ |
| public GeneratedJavaParser(GeneratedJavaParserTokenManager tm) { |
| token_source = tm; |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 164; i++) jj_la1[i] = -1; |
| for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); |
| } |
| |
| /** Reinitialise. */ |
| public void ReInit(GeneratedJavaParserTokenManager tm) { |
| token_source = tm; |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 164; i++) jj_la1[i] = -1; |
| for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); |
| } |
| |
| 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(); |
| } |
| |
| @SuppressWarnings("serial") |
| static private final class LookaheadSuccess extends java.lang.RuntimeException { } |
| final private LookaheadSuccess jj_ls = new LookaheadSuccess(); |
| 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); |
| } |
| if (jj_scanpos.kind != kind) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; |
| return false; |
| } |
| |
| |
| /** Get the next Token. */ |
| 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; |
| } |
| |
| /** Get the specific Token. */ |
| final public Token getToken(int index) { |
| Token t = jj_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; |
| } |
| |
| private int jj_ntk_f() { |
| 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.List<int[]> jj_expentries = new java.util.ArrayList<int[]>(); |
| 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]; |
| } |
| |
| for (int[] oldentry : jj_expentries) { |
| if (oldentry.length == jj_expentry.length) { |
| boolean isMatched = true; |
| |
| for (int i = 0; i < jj_expentry.length; i++) { |
| if (oldentry[i] != jj_expentry[i]) { |
| isMatched = false; |
| break; |
| } |
| |
| } |
| if (isMatched) { |
| jj_expentries.add(jj_expentry); |
| break; |
| } |
| } |
| } |
| |
| if (pos != 0) { |
| jj_lasttokens[(jj_endpos = pos) - 1] = kind; |
| } |
| } |
| } |
| |
| /** Generate ParseException. */ |
| public ParseException generateParseException() { |
| jj_expentries.clear(); |
| boolean[] la1tokens = new boolean[143]; |
| if (jj_kind >= 0) { |
| la1tokens[jj_kind] = true; |
| jj_kind = -1; |
| } |
| for (int i = 0; i < 164; 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; |
| } |
| if ((jj_la1_4[i] & (1<<j)) != 0) { |
| la1tokens[128+j] = true; |
| } |
| } |
| } |
| } |
| for (int i = 0; i < 143; i++) { |
| if (la1tokens[i]) { |
| jj_expentry = new int[1]; |
| jj_expentry[0] = i; |
| jj_expentries.add(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] = jj_expentries.get(i); |
| } |
| return new ParseException(token, exptokseq, tokenImage, token_source == null ? null : GeneratedJavaParserTokenManager.lexStateNames[token_source.curLexState]); |
| } |
| |
| private int trace_indent = 0; |
| private boolean trace_enabled; |
| |
| /** Trace enabled. */ |
| final public boolean trace_enabled() { |
| return trace_enabled; |
| } |
| |
| /** Enable tracing. */ |
| final public void enable_tracing() { |
| } |
| |
| /** Disable tracing. */ |
| final public void disable_tracing() { |
| } |
| |
| private void jj_rescan_token() { |
| jj_rescan = true; |
| for (int i = 0; i < 58; i++) { |
| try { |
| 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; |
| case 52: jj_3_53(); break; |
| case 53: jj_3_54(); break; |
| case 54: jj_3_55(); break; |
| case 55: jj_3_56(); break; |
| case 56: jj_3_57(); break; |
| case 57: jj_3_58(); break; |
| } |
| } |
| p = p.next; |
| } while (p != null); |
| |
| } catch(LookaheadSuccess ls) { } |
| } |
| jj_rescan = false; |
| } |
| |
| 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; |
| } |
| |
| } |