| /* ASTParser.java */ |
| /* Generated By:JavaCC: Do not edit this line. ASTParser.java */ |
| /* |
| * |
| * This file is part of Java 1.8 parser and Abstract Syntax Tree. |
| * |
| * Java 1.8 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify |
| * it under the terms of 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. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with Java 1.8 parser and Abstract Syntax Tree. If not, see <http://www.gnu.org/licenses/>. |
| */ |
| 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.expr.*; |
| import com.github.javaparser.ast.stmt.*; |
| import com.github.javaparser.ast.type.*; |
| import com.github.javaparser.utils.*; |
| import static com.github.javaparser.ASTParser.*; |
| import static com.github.javaparser.Range.*; |
| import static com.github.javaparser.Position.*; |
| import static com.github.javaparser.ast.type.ArrayType.*; |
| |
| /** |
| * <p>This class was generated automatically by javacc, do not edit.</p> |
| */ |
| final class ASTParser implements ASTParserConstants { |
| |
| private final Position INVALID = pos(-1, 0); |
| List<Problem> problems = new ArrayList<Problem>(); |
| |
| void reset(InputStream in, String encoding) throws IOException { |
| ReInit(new StreamProvider(in, encoding)); |
| } |
| |
| private <T> List<T> add(List<T> list, T obj) { |
| if (list == null) { |
| list = new LinkedList<T>(); |
| } |
| list.add(obj); |
| return list; |
| } |
| |
| private <T> List<T> add(int pos, List<T> list, T obj) { |
| if (list == null) { |
| list = new LinkedList<T>(); |
| } |
| list.add(pos, obj); |
| return list; |
| } |
| |
| private class ModifierHolder { |
| final EnumSet<Modifier> modifiers; |
| final List<AnnotationExpr> annotations; |
| final Position begin; |
| |
| public ModifierHolder(Position begin, EnumSet<Modifier> modifiers, List<AnnotationExpr> annotations) { |
| this.begin = begin; |
| this.modifiers = modifiers; |
| this.annotations = annotations; |
| } |
| } |
| |
| public void addModifier(EnumSet<Modifier> modifiers, Modifier mod) { |
| if (modifiers.contains(mod)) { |
| addProblem("Duplicated modifier"); |
| } |
| modifiers.add(mod); |
| } |
| |
| public void addMultipleModifier(EnumSet<Modifier> modifiers, EnumSet<Modifier> mods) { |
| if(mods == null) |
| return; |
| for(Modifier m : mods) |
| if (modifiers.contains(m)) |
| addProblem("Duplicated modifier"); |
| for(Modifier m : mods) |
| modifiers.add(m); |
| } |
| |
| /** |
| * Return the list of tokens that have been encountered while parsing code using |
| * this parser. |
| * |
| * @return a list of tokens |
| */ |
| public List<Token> getTokens() { |
| return token_source.getTokens(); |
| } |
| |
| public CommentsCollection getCommentsCollection() { |
| return token_source.getCommentsCollection(); |
| } |
| |
| private void addProblem(String message) { |
| problems.add(new Problem(message + ": \"" + token.image, Optional.of(tokenRange()), Optional.empty())); |
| } |
| |
| private Expression generateLambda(Expression ret, Statement lambdaBody) { |
| if (ret instanceof EnclosedExpr) { |
| Expression inner = ((EnclosedExpr) ret).getInner(); |
| if (inner != null && inner instanceof NameExpr) { |
| VariableDeclaratorId id = new VariableDeclaratorId(inner.getRange(), ((NameExpr)inner).getName(), null); |
| List<Parameter> params = add(null, new Parameter(ret.getRange(), EnumSet.noneOf(Modifier.class), null, new UnknownType(), null, false, id)); |
| ret = new LambdaExpr(range(ret.getBegin(), lambdaBody.getEnd()), params, lambdaBody, true); |
| } else { |
| ret = new LambdaExpr(range(ret.getBegin(), lambdaBody.getEnd()), null, lambdaBody, true); |
| } |
| } else if (ret instanceof NameExpr) { |
| VariableDeclaratorId id = new VariableDeclaratorId(ret.getRange(), ((NameExpr)ret).getName(), null); |
| List<Parameter> params = add(null, new Parameter(ret.getRange(), EnumSet.noneOf(Modifier.class), null, new UnknownType(), null, false, id)); |
| ret = new LambdaExpr(ret.getRange(), params, lambdaBody, false); |
| } else if (ret instanceof LambdaExpr) { |
| ((LambdaExpr) ret).setBody(lambdaBody); |
| ret.setEnd(lambdaBody.getEnd()); |
| } else if (ret instanceof CastExpr) { |
| CastExpr castExpr = (CastExpr)ret; |
| Expression inner = generateLambda(castExpr.getExpr(), lambdaBody); |
| castExpr.setExpr(inner); |
| } else { |
| addProblem("Failed to parse lambda expression! Please create an issue at https://github.com/javaparser/javaparser/issues"); |
| } |
| return ret; |
| } |
| |
| private ArrayCreationExpr juggleArrayCreation(Range range, Type type, List<Expression> dimensions, List<List<AnnotationExpr>> arrayAnnotations, ArrayInitializerExpr arrayInitializerExpr) { |
| List<ArrayCreationLevel> levels = new ArrayList<ArrayCreationLevel>(); |
| |
| for(int i = 0; i < arrayAnnotations.size(); i++){ |
| levels.add(new ArrayCreationLevel(range, dimensions.get(i), arrayAnnotations.get(i))); |
| } |
| return new ArrayCreationExpr(range, type, levels, arrayInitializerExpr); |
| } |
| |
| |
| static final class GTToken extends Token { |
| int realKind = ASTParserConstants.GT; |
| |
| GTToken(int kind, String image) { |
| this.kind = kind; |
| this.image = image; |
| } |
| |
| public static Token newToken(int kind, String image) { |
| return new GTToken(kind, image); |
| } |
| } |
| |
| private static class RangedList<T> { |
| Range range = Range.UNKNOWN; |
| List<T> list; |
| RangedList(List<T> list) { |
| this.list = list; |
| } |
| void beginAt(Position begin) { |
| range=range.withBegin(begin); |
| } |
| void endAt(Position end) { |
| range=range.withEnd(end); |
| } |
| void add(T t) { |
| if (list == null) { |
| list = new LinkedList<T>(); |
| } |
| list.add(t); |
| } |
| } |
| |
| private Position tokenBegin() { |
| return pos(token.beginLine,token.beginColumn); |
| } |
| |
| private Position tokenEnd() { |
| return pos(token.endLine,token.endColumn); |
| } |
| |
| private Range tokenRange() { |
| return tokenRange(token); |
| } |
| |
| public static Range tokenRange(Token token) { |
| return range(token.beginLine, token.beginColumn, token.endLine, token.endColumn); |
| } |
| |
| /***************************************** |
| * THE JAVA LANGUAGE GRAMMAR STARTS HERE * |
| *****************************************/ |
| |
| /* |
| * Program structuring syntax follows. |
| */ |
| final public |
| CompilationUnit CompilationUnit() {PackageDeclaration pakage = null; |
| List<ImportDeclaration> imports = null; |
| ImportDeclaration in = null; |
| List<TypeDeclaration<?>> types = null; |
| TypeDeclaration tn = null; |
| Position begin = INVALID; |
| if (jj_2_1(2147483647)) { |
| pakage = PackageDeclaration(); |
| begin = begin.orIfInvalid(pakage.getBegin()); |
| } else { |
| ; |
| } |
| label_1: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IMPORT: |
| case SEMICOLON:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[0] = jj_gen; |
| break label_1; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IMPORT:{ |
| in = ImportDeclaration(); |
| begin = begin.orIfInvalid(in.getBegin()); imports = add(imports, in); |
| break; |
| } |
| case SEMICOLON:{ |
| in = EmptyImportDeclaration(); |
| begin = begin.orIfInvalid(in.getBegin()); imports = add(imports, in); |
| break; |
| } |
| default: |
| jj_la1[1] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| label_2: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case CLASS: |
| 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 SEMICOLON: |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[2] = jj_gen; |
| break label_2; |
| } |
| tn = TypeDeclaration(); |
| begin = begin.orIfInvalid(tn.getBegin()); types = add(types, tn); |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case 0:{ |
| jj_consume_token(0); |
| break; |
| } |
| case 156:{ |
| jj_consume_token(156); |
| break; |
| } |
| default: |
| jj_la1[3] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return new CompilationUnit(begin.invalid() ? Range.UNKNOWN : range(begin, tokenEnd()), pakage, imports, types); |
| } |
| |
| final public ImportDeclaration EmptyImportDeclaration() {Position begin; |
| jj_consume_token(SEMICOLON); |
| begin = tokenBegin(); |
| return ImportDeclaration.createEmptyDeclaration(range(begin, tokenEnd())); |
| } |
| |
| final public PackageDeclaration PackageDeclaration() {List<AnnotationExpr> annotations = null; |
| NameExpr name; |
| Position begin; |
| annotations = Annotations(); |
| jj_consume_token(PACKAGE); |
| begin = tokenBegin(); |
| name = Name(); |
| jj_consume_token(SEMICOLON); |
| return new PackageDeclaration(range(begin, tokenEnd()), annotations, name); |
| } |
| |
| final public ImportDeclaration ImportDeclaration() {NameExpr name; |
| boolean isStatic = false; |
| boolean isAsterisk = false; |
| Position begin; |
| jj_consume_token(IMPORT); |
| begin = tokenBegin(); |
| 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, tokenEnd()),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() {Position begin = INVALID; |
| EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class); |
| List<AnnotationExpr> annotations = null; |
| AnnotationExpr ann; |
| label_3: |
| while (true) { |
| if (jj_2_2(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 = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case STATIC:{ |
| jj_consume_token(STATIC); |
| addModifier(modifiers, Modifier.STATIC); begin = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case PROTECTED:{ |
| jj_consume_token(PROTECTED); |
| addModifier(modifiers, Modifier.PROTECTED); begin = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case PRIVATE:{ |
| jj_consume_token(PRIVATE); |
| addModifier(modifiers, Modifier.PRIVATE); begin = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case FINAL:{ |
| jj_consume_token(FINAL); |
| addModifier(modifiers, Modifier.FINAL); begin = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case ABSTRACT:{ |
| jj_consume_token(ABSTRACT); |
| addModifier(modifiers, Modifier.ABSTRACT); begin = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case SYNCHRONIZED:{ |
| jj_consume_token(SYNCHRONIZED); |
| addModifier(modifiers, Modifier.SYNCHRONIZED); begin = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case NATIVE:{ |
| jj_consume_token(NATIVE); |
| addModifier(modifiers, Modifier.NATIVE); begin = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case TRANSIENT:{ |
| jj_consume_token(TRANSIENT); |
| addModifier(modifiers, Modifier.TRANSIENT); begin = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case VOLATILE:{ |
| jj_consume_token(VOLATILE); |
| addModifier(modifiers, Modifier.VOLATILE); begin = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case STRICTFP:{ |
| jj_consume_token(STRICTFP); |
| addModifier(modifiers, Modifier.STRICTFP); begin = begin.orIfInvalid(tokenBegin()); |
| break; |
| } |
| case AT:{ |
| ann = Annotation(); |
| annotations = add(annotations, ann); begin = begin.orIfInvalid(ann.getBegin()); |
| 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 TypeDeclaration TypeDeclaration() {ModifierHolder modifier; |
| TypeDeclaration ret; |
| |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case SEMICOLON:{ |
| jj_consume_token(SEMICOLON); |
| ret = new EmptyTypeDeclaration(tokenRange()); |
| break; |
| } |
| case ABSTRACT: |
| case CLASS: |
| 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 AT:{ |
| modifier = Modifiers(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CLASS: |
| case INTERFACE:{ |
| ret = ClassOrInterfaceDeclaration(modifier); |
| break; |
| } |
| case ENUM:{ |
| ret = EnumDeclaration(modifier); |
| break; |
| } |
| case AT:{ |
| ret = AnnotationTypeDeclaration(modifier); |
| break; |
| } |
| default: |
| jj_la1[7] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| } |
| default: |
| jj_la1[8] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public ClassOrInterfaceDeclaration ClassOrInterfaceDeclaration(ModifierHolder modifier) {boolean isInterface = false; |
| NameExpr name; |
| RangedList<TypeParameter> typePar = new RangedList<TypeParameter>(null); |
| List<ClassOrInterfaceType> extList = null; |
| List<ClassOrInterfaceType> impList = null; |
| List<BodyDeclaration<?>> members; |
| Position 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[9] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| begin = begin.orIfInvalid(tokenBegin()); |
| name = Name(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typePar = TypeParameters(); |
| break; |
| } |
| default: |
| jj_la1[10] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case EXTENDS:{ |
| extList = ExtendsList(isInterface); |
| break; |
| } |
| default: |
| jj_la1[11] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IMPLEMENTS:{ |
| impList = ImplementsList(isInterface); |
| break; |
| } |
| default: |
| jj_la1[12] = jj_gen; |
| ; |
| } |
| members = ClassOrInterfaceBody(isInterface); |
| ClassOrInterfaceDeclaration tmp = new ClassOrInterfaceDeclaration(range(begin, tokenEnd()), modifier.modifiers, modifier.annotations, isInterface, null, typePar.list, extList, impList, members); |
| tmp.setNameExpr(name); |
| return tmp; |
| } |
| |
| final public List<ClassOrInterfaceType> ExtendsList(boolean isInterface) {boolean extendsMoreThanOne = false; |
| List<ClassOrInterfaceType> ret = new LinkedList<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[13] = jj_gen; |
| break label_4; |
| } |
| jj_consume_token(COMMA); |
| cit = AnnotatedClassOrInterfaceType(); |
| ret.add(cit); extendsMoreThanOne = true; |
| } |
| if (extendsMoreThanOne && !isInterface) |
| addProblem("A class cannot extend more than one other class"); |
| return ret; |
| } |
| |
| final public List<ClassOrInterfaceType> ImplementsList(boolean isInterface) {List<ClassOrInterfaceType> ret = new LinkedList<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[14] = jj_gen; |
| break label_5; |
| } |
| jj_consume_token(COMMA); |
| cit = AnnotatedClassOrInterfaceType(); |
| ret.add(cit); |
| } |
| if (isInterface) |
| addProblem("An interface cannot implement other interfaces"); |
| return ret; |
| } |
| |
| final public EnumDeclaration EnumDeclaration(ModifierHolder modifier) {NameExpr name; |
| List<ClassOrInterfaceType> impList = null; |
| EnumConstantDeclaration entry; |
| List<EnumConstantDeclaration> entries = null; |
| BodyDeclaration<?> member; |
| List<BodyDeclaration<?>> members = null; |
| Position begin = modifier.begin; |
| jj_consume_token(ENUM); |
| begin = begin.orIfInvalid(tokenBegin()); |
| name = Name(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IMPLEMENTS:{ |
| impList = ImplementsList(false); |
| break; |
| } |
| default: |
| jj_la1[15] = jj_gen; |
| ; |
| } |
| jj_consume_token(LBRACE); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IDENTIFIER: |
| case AT:{ |
| entries = new LinkedList<EnumConstantDeclaration>(); |
| entry = EnumConstantDeclaration(); |
| entries.add(entry); |
| label_6: |
| while (true) { |
| if (jj_2_3(2)) { |
| ; |
| } else { |
| break label_6; |
| } |
| jj_consume_token(COMMA); |
| entry = EnumConstantDeclaration(); |
| entries.add(entry); |
| } |
| break; |
| } |
| default: |
| jj_la1[16] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| jj_consume_token(COMMA); |
| break; |
| } |
| default: |
| jj_la1[17] = 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 IDENTIFIER: |
| case LBRACE: |
| case SEMICOLON: |
| case AT: |
| case LT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[18] = jj_gen; |
| break label_7; |
| } |
| member = ClassOrInterfaceBodyDeclaration(false); |
| members = add(members, member); |
| } |
| break; |
| } |
| default: |
| jj_la1[19] = jj_gen; |
| ; |
| } |
| jj_consume_token(RBRACE); |
| EnumDeclaration tmp = new EnumDeclaration(range(begin, tokenEnd()), modifier.modifiers, modifier.annotations, null, impList, entries, members); |
| tmp.setNameExpr(name); |
| return tmp; |
| } |
| |
| final public EnumConstantDeclaration EnumConstantDeclaration() {List<AnnotationExpr> annotations = null; |
| AnnotationExpr ann; |
| String name; |
| List<Expression> args = null; |
| List<BodyDeclaration<?>> classBody = null; |
| Position begin = INVALID; |
| |
| label_8: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[20] = jj_gen; |
| break label_8; |
| } |
| ann = Annotation(); |
| annotations = add(annotations, ann); begin = begin.orIfInvalid(ann.getBegin()); |
| } |
| jj_consume_token(IDENTIFIER); |
| name = token.image; begin = begin.orIfInvalid(tokenBegin()); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LPAREN:{ |
| args = Arguments(); |
| break; |
| } |
| default: |
| jj_la1[21] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACE:{ |
| classBody = ClassOrInterfaceBody(false); |
| break; |
| } |
| default: |
| jj_la1[22] = jj_gen; |
| ; |
| } |
| return new EnumConstantDeclaration(range(begin, tokenEnd()), 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() {RangedList<TypeParameter> ret = new RangedList<TypeParameter>(new LinkedList<TypeParameter>()); |
| TypeParameter tp; |
| List<AnnotationExpr> annotations = null; |
| jj_consume_token(LT); |
| ret.beginAt(tokenBegin()); |
| annotations = Annotations(); |
| tp = TypeParameter(); |
| ret.add(tp); tp.setAnnotations(annotations); annotations = null; |
| label_9: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[23] = jj_gen; |
| break label_9; |
| } |
| jj_consume_token(COMMA); |
| annotations = Annotations(); |
| tp = TypeParameter(); |
| ret.add(tp); tp.setAnnotations(annotations); annotations = null; |
| } |
| jj_consume_token(GT); |
| ret.endAt(tokenEnd()); |
| return ret; |
| } |
| |
| final public TypeParameter TypeParameter() {String name; |
| List<ClassOrInterfaceType> typeBound = null; |
| Position begin; |
| jj_consume_token(IDENTIFIER); |
| name = token.image; begin=tokenBegin(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case EXTENDS:{ |
| typeBound = TypeBound(); |
| break; |
| } |
| default: |
| jj_la1[24] = jj_gen; |
| ; |
| } |
| return new TypeParameter(range(begin, tokenEnd()),name, typeBound); |
| } |
| |
| final public List<ClassOrInterfaceType> TypeBound() {List<ClassOrInterfaceType> ret = new LinkedList<ClassOrInterfaceType>(); |
| 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[25] = jj_gen; |
| break label_10; |
| } |
| jj_consume_token(BIT_AND); |
| cit = AnnotatedClassOrInterfaceType(); |
| ret.add(cit); |
| } |
| return ret; |
| } |
| |
| final public List<BodyDeclaration<?>> ClassOrInterfaceBody(boolean isInterface) {List<BodyDeclaration<?>> ret = new LinkedList<BodyDeclaration<?>>(); |
| 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 IDENTIFIER: |
| case LBRACE: |
| case SEMICOLON: |
| case AT: |
| case LT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[26] = jj_gen; |
| break label_11; |
| } |
| member = ClassOrInterfaceBodyDeclaration(isInterface); |
| ret.add(member); |
| } |
| jj_consume_token(RBRACE); |
| return ret; |
| } |
| |
| final public BodyDeclaration<?> ClassOrInterfaceBodyDeclaration(boolean isInterface) {ModifierHolder modifier; |
| ModifierHolder modifier2 = null; |
| EnumSet<Modifier> aux = null; |
| BodyDeclaration<?> ret; |
| boolean isDefault = false; |
| |
| if (jj_2_6(2)) { |
| ret = InitializerDeclaration(); |
| if (isInterface) |
| addProblem("An interface cannot have initializers"); |
| } 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 IDENTIFIER: |
| case AT: |
| case LT:{ |
| modifier = Modifiers(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case _DEFAULT:{ |
| jj_consume_token(_DEFAULT); |
| modifier2 = Modifiers(); |
| if(!isInterface) |
| { |
| addProblem("A class cannot have default members"); |
| } |
| isDefault = true; |
| break; |
| } |
| default: |
| jj_la1[27] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CLASS: |
| case INTERFACE:{ |
| ret = ClassOrInterfaceDeclaration(modifier); |
| break; |
| } |
| case ENUM:{ |
| ret = EnumDeclaration(modifier); |
| break; |
| } |
| case AT:{ |
| ret = AnnotationTypeDeclaration(modifier); |
| break; |
| } |
| default: |
| jj_la1[28] = jj_gen; |
| if (jj_2_4(2147483647)) { |
| ret = ConstructorDeclaration(modifier); |
| } else if (jj_2_5(2147483647)) { |
| ret = FieldDeclaration(modifier); |
| } 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: |
| case VOID: |
| case IDENTIFIER: |
| case LT:{ |
| ret = MethodDeclaration(modifier); |
| if(isDefault && ret!= null && ((MethodDeclaration)ret).getBody() == null) |
| { |
| addProblem("\"default\" methods must have a body"); |
| } |
| ((MethodDeclaration)ret).setDefault(isDefault); |
| if(modifier2!= null) |
| { |
| aux = modifier2.modifiers; |
| } |
| addMultipleModifier(modifier.modifiers, aux); |
| ((MethodDeclaration)ret).setModifiers(modifier.modifiers); |
| break; |
| } |
| default: |
| jj_la1[29] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| if(isDefault && ! (ret instanceof MethodDeclaration)) |
| { |
| addProblem("Only methods can have the keyword \"default\"."); |
| } |
| break; |
| } |
| case SEMICOLON:{ |
| jj_consume_token(SEMICOLON); |
| ret = new EmptyMemberDeclaration(tokenRange()); |
| break; |
| } |
| default: |
| jj_la1[30] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public FieldDeclaration FieldDeclaration(ModifierHolder modifier) {Type type; |
| List<VariableDeclarator> variables = new LinkedList<VariableDeclarator>(); |
| VariableDeclarator val; |
| // Modifiers are already matched in the caller |
| type = Type(); |
| val = VariableDeclarator(); |
| variables.add(val); |
| label_12: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[31] = jj_gen; |
| break label_12; |
| } |
| jj_consume_token(COMMA); |
| val = VariableDeclarator(); |
| variables.add(val); |
| } |
| jj_consume_token(SEMICOLON); |
| Position begin = modifier.begin.orIfInvalid(type.getBegin()); |
| Pair<Type, List<ArrayBracketPair>> typeListPair = unwrapArrayTypes(type); |
| return new FieldDeclaration(range(begin, tokenEnd()), modifier.modifiers, modifier.annotations, typeListPair.a, variables, typeListPair.b); |
| } |
| |
| final public VariableDeclarator VariableDeclarator() {VariableDeclaratorId 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[32] = jj_gen; |
| ; |
| } |
| return new VariableDeclarator(range(id.getBegin(), tokenEnd()), id, init); |
| } |
| |
| final public VariableDeclaratorId VariableDeclaratorId() {String name; |
| Position begin; |
| ArrayBracketPair arrayBracketPair; |
| List<ArrayBracketPair> arrayBracketPairs = null; |
| jj_consume_token(IDENTIFIER); |
| name = token.image; begin=tokenBegin(); |
| label_13: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACKET: |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[33] = jj_gen; |
| break label_13; |
| } |
| arrayBracketPair = ArrayBracketPair(); |
| arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); |
| } |
| return new VariableDeclaratorId(range(begin, tokenEnd()),name, arrayBracketPairs); |
| } |
| |
| final public Expression VariableInitializer() {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 FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| ret = Expression(); |
| break; |
| } |
| default: |
| jj_la1[34] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public ArrayInitializerExpr ArrayInitializer() {List<Expression> values = null; |
| Expression val; |
| Position begin; |
| jj_consume_token(LBRACE); |
| begin=tokenBegin(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case LBRACE: |
| 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_7(2)) { |
| ; |
| } else { |
| break label_14; |
| } |
| jj_consume_token(COMMA); |
| val = VariableInitializer(); |
| values = add(values, val); |
| } |
| break; |
| } |
| default: |
| jj_la1[35] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| jj_consume_token(COMMA); |
| break; |
| } |
| default: |
| jj_la1[36] = jj_gen; |
| ; |
| } |
| jj_consume_token(RBRACE); |
| return new ArrayInitializerExpr(range(begin, tokenEnd()), values); |
| } |
| |
| final public MethodDeclaration MethodDeclaration(ModifierHolder modifier) {RangedList<TypeParameter> typeParameters = new RangedList<TypeParameter>(null); |
| Type type; |
| NameExpr name; |
| List<Parameter> parameters; |
| ArrayBracketPair arrayBracketPair; |
| List<ArrayBracketPair> arrayBracketPairs = null; |
| List<ReferenceType> throws_ = null; |
| BlockStmt block = null; |
| Position begin = modifier.begin; |
| ReferenceType throwType; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeParameters = TypeParameters(); |
| begin = begin.orIfInvalid(typeParameters.range.begin); |
| break; |
| } |
| default: |
| jj_la1[37] = jj_gen; |
| ; |
| } |
| type = ResultType(); |
| begin = begin.orIfInvalid(type.getBegin()); |
| name = Name(); |
| parameters = FormalParameters(); |
| label_15: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACKET: |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[38] = jj_gen; |
| break label_15; |
| } |
| arrayBracketPair = ArrayBracketPair(); |
| arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case THROWS:{ |
| jj_consume_token(THROWS); |
| throwType = ReferenceTypeWithAnnotations(); |
| throws_ = add(throws_, throwType); |
| label_16: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[39] = jj_gen; |
| break label_16; |
| } |
| jj_consume_token(COMMA); |
| throwType = ReferenceTypeWithAnnotations(); |
| throws_ = add(throws_, throwType); |
| } |
| break; |
| } |
| default: |
| jj_la1[40] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACE:{ |
| block = Block(); |
| break; |
| } |
| case SEMICOLON:{ |
| jj_consume_token(SEMICOLON); |
| break; |
| } |
| default: |
| jj_la1[41] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| Pair<Type, List<ArrayBracketPair>> typeListPair = unwrapArrayTypes(type); |
| return new MethodDeclaration(range(begin, pos(token.endLine, token.endColumn)), modifier.modifiers, modifier.annotations, typeParameters.list, typeListPair.a, typeListPair.b, name, parameters, arrayBracketPairs, throws_, block); |
| } |
| |
| final public ReferenceType ReferenceTypeWithAnnotations() {List<AnnotationExpr> annotations; |
| ReferenceType type; |
| annotations = Annotations(); |
| type = ReferenceType(); |
| if(annotations != null){ |
| if (type.getAnnotations() != null) { |
| type.getAnnotations().addAll(annotations); |
| } else { |
| type.setAnnotations(annotations); |
| } |
| } |
| return type; |
| } |
| |
| final public List<Parameter> FormalParameters() {List<Parameter> ret = null; |
| Parameter par; |
| jj_consume_token(LPAREN); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| 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 IDENTIFIER: |
| case AT:{ |
| par = FormalParameter(); |
| ret = add(ret, par); |
| 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 = FormalParameter(); |
| ret = add(ret, par); |
| } |
| break; |
| } |
| default: |
| jj_la1[43] = jj_gen; |
| ; |
| } |
| jj_consume_token(RPAREN); |
| return ret; |
| } |
| |
| final public List<Parameter> FormalLambdaParameters() {List<Parameter> ret = null; |
| Parameter par; |
| jj_consume_token(COMMA); |
| par = FormalParameter(); |
| 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 = FormalParameter(); |
| ret = add(ret, par); |
| } |
| return ret; |
| } |
| |
| final public List<Parameter> InferredLambdaParameters() {List<Parameter> ret = null; |
| VariableDeclaratorId id; |
| jj_consume_token(COMMA); |
| id = VariableDeclaratorId(); |
| ret = add(ret, new Parameter(range(id.getBegin(), id.getEnd()), EnumSet.noneOf(Modifier.class), null, new UnknownType(), null, false, id)); |
| 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.getBegin(), id.getEnd()), EnumSet.noneOf(Modifier.class), null, new UnknownType(), null, false, id)); |
| } |
| return ret; |
| } |
| |
| final public Parameter FormalParameter() {ModifierHolder modifier; |
| Type type; |
| boolean isVarArg = false; |
| VariableDeclaratorId id; |
| modifier = Modifiers(); |
| type = Type(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ELLIPSIS:{ |
| jj_consume_token(ELLIPSIS); |
| isVarArg = true; |
| break; |
| } |
| default: |
| jj_la1[46] = jj_gen; |
| ; |
| } |
| id = VariableDeclaratorId(); |
| Position begin = modifier.begin.orIfInvalid(type.getBegin()); |
| Pair<Type, List<ArrayBracketPair>> typeListPair = unwrapArrayTypes(type); |
| return new Parameter(range(begin, tokenEnd()), modifier.modifiers, modifier.annotations, typeListPair.a, typeListPair.b, isVarArg, id); |
| } |
| |
| final public ConstructorDeclaration ConstructorDeclaration(ModifierHolder modifier) {RangedList<TypeParameter> typeParameters = new RangedList<TypeParameter>(null); |
| NameExpr name; |
| List<Parameter> parameters; |
| List<ReferenceType> throws_ = null; |
| ExplicitConstructorInvocationStmt exConsInv = null; |
| List<Statement> stmts; |
| Position begin = modifier.begin; |
| Position blockBegin = INVALID; |
| ReferenceType throwType; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeParameters = TypeParameters(); |
| begin = begin.orIfInvalid(typeParameters.range.begin); |
| break; |
| } |
| default: |
| jj_la1[47] = jj_gen; |
| ; |
| } |
| // Modifiers matched in the caller |
| name = SimpleName(); |
| begin = begin.orIfInvalid(typeParameters.range.begin); |
| parameters = FormalParameters(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case THROWS:{ |
| jj_consume_token(THROWS); |
| throwType = ReferenceTypeWithAnnotations(); |
| 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 = ReferenceTypeWithAnnotations(); |
| throws_ = add(throws_, throwType); |
| } |
| break; |
| } |
| default: |
| jj_la1[49] = jj_gen; |
| ; |
| } |
| jj_consume_token(LBRACE); |
| blockBegin=tokenBegin(); |
| if (jj_2_8(2147483647)) { |
| exConsInv = ExplicitConstructorInvocation(); |
| } else { |
| ; |
| } |
| stmts = Statements(); |
| jj_consume_token(RBRACE); |
| if (exConsInv != null) { |
| stmts = add(0, stmts, exConsInv); |
| } |
| ConstructorDeclaration tmp = new ConstructorDeclaration(range(begin, pos(token.endLine, token.endColumn)), modifier.modifiers, modifier.annotations, typeParameters.list, null, parameters, throws_, new BlockStmt(range(blockBegin, tokenEnd()), stmts)); |
| tmp.setNameExpr(name); |
| return tmp; |
| } |
| |
| final public ExplicitConstructorInvocationStmt ExplicitConstructorInvocation() {boolean isThis = false; |
| List<Expression> args; |
| Expression expr = null; |
| RangedList<Type<?>> typeArgs = new RangedList<Type<?>>(null); |
| Position begin = INVALID; |
| if (jj_2_10(2147483647)) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| begin=typeArgs.range.begin; |
| break; |
| } |
| default: |
| jj_la1[50] = jj_gen; |
| ; |
| } |
| jj_consume_token(THIS); |
| begin = begin.orIfInvalid(tokenBegin()); 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 FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case LT:{ |
| if (jj_2_9(2147483647)) { |
| expr = PrimaryExpressionWithoutSuperSuffix(); |
| jj_consume_token(DOT); |
| begin=expr.getBegin(); |
| } else { |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| begin = begin.orIfInvalid(typeArgs.range.begin); |
| break; |
| } |
| default: |
| jj_la1[51] = jj_gen; |
| ; |
| } |
| jj_consume_token(SUPER); |
| begin = begin.orIfInvalid(tokenBegin()); |
| 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, tokenEnd()),typeArgs.list, isThis, expr, args); |
| } |
| |
| final public List<Statement> Statements() {List<Statement> ret = null; |
| Statement stmt; |
| label_21: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case ASSERT: |
| case BOOLEAN: |
| case BREAK: |
| case BYTE: |
| case CHAR: |
| case CLASS: |
| case CONTINUE: |
| case DO: |
| case DOUBLE: |
| case FALSE: |
| case FINAL: |
| case FLOAT: |
| case FOR: |
| case IF: |
| case INT: |
| case INTERFACE: |
| case LONG: |
| case NATIVE: |
| case NEW: |
| case NULL: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case RETURN: |
| case SHORT: |
| case STATIC: |
| case STRICTFP: |
| case SUPER: |
| case SWITCH: |
| case SYNCHRONIZED: |
| case THIS: |
| case THROW: |
| case TRANSIENT: |
| case TRUE: |
| case TRY: |
| case VOID: |
| case VOLATILE: |
| case WHILE: |
| 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:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[53] = jj_gen; |
| break label_21; |
| } |
| stmt = BlockStatement(); |
| ret = add(ret, stmt); |
| } |
| return ret; |
| } |
| |
| final public InitializerDeclaration InitializerDeclaration() {BlockStmt block; |
| Position begin = INVALID; |
| boolean isStatic = false; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case STATIC:{ |
| jj_consume_token(STATIC); |
| isStatic = true; begin=tokenBegin(); |
| break; |
| } |
| default: |
| jj_la1[54] = jj_gen; |
| ; |
| } |
| block = Block(); |
| begin = begin.orIfInvalid(block.getBegin()); |
| return new InitializerDeclaration(range(begin, tokenEnd()), isStatic, block); |
| } |
| |
| /* |
| * Type, name and expression syntax follows. |
| */ |
| final public |
| Type Type() {Type ret; |
| if (jj_2_11(2)) { |
| ret = ReferenceType(); |
| } 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(); |
| break; |
| } |
| default: |
| jj_la1[55] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public ReferenceType ReferenceType() {Type type; |
| ArrayBracketPair arrayBracketPair; |
| List<ArrayBracketPair> arrayBracketPairs = null; |
| 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(); |
| label_22: |
| while (true) { |
| arrayBracketPair = ArrayBracketPair(); |
| arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); |
| if (jj_2_12(2)) { |
| ; |
| } else { |
| break label_22; |
| } |
| } |
| break; |
| } |
| case IDENTIFIER:{ |
| type = ClassOrInterfaceType(); |
| label_23: |
| while (true) { |
| if (jj_2_13(2)) { |
| ; |
| } else { |
| break label_23; |
| } |
| arrayBracketPair = ArrayBracketPair(); |
| arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); |
| } |
| break; |
| } |
| default: |
| jj_la1[56] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return (ReferenceType)wrapInArrayTypes(type, arrayBracketPairs); |
| } |
| |
| final public ArrayBracketPair ArrayBracketPair() {List<AnnotationExpr> annotations = null; |
| Position begin = INVALID; |
| annotations = Annotations(); |
| jj_consume_token(LBRACKET); |
| begin = begin.orIfInvalid(tokenBegin()); |
| jj_consume_token(RBRACKET); |
| return new ArrayBracketPair(range(begin, tokenEnd()), annotations); |
| } |
| |
| final public IntersectionType IntersectionType() {Position begin; |
| ReferenceType elementType; |
| List<ReferenceType> elements = null; |
| elementType = ReferenceType(); |
| begin=elementType.getBegin(); elements = add(elements, elementType); |
| jj_consume_token(BIT_AND); |
| label_24: |
| while (true) { |
| elementType = ReferenceType(); |
| elements = add(elements, elementType); |
| 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: |
| case IDENTIFIER:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[57] = jj_gen; |
| break label_24; |
| } |
| } |
| return new IntersectionType(range(begin, tokenEnd()), elements); |
| } |
| |
| final public ClassOrInterfaceType AnnotatedClassOrInterfaceType() {List<AnnotationExpr> annotations; |
| ClassOrInterfaceType cit; |
| annotations = Annotations(); |
| cit = ClassOrInterfaceType(); |
| if (cit.getScope()!=null) { |
| cit.getScope().setAnnotations(annotations); |
| } else { |
| cit.setAnnotations(annotations); |
| } |
| return cit; |
| } |
| |
| final public ClassOrInterfaceType ClassOrInterfaceType() {ClassOrInterfaceType ret; |
| String name; |
| RangedList<Type<?>> typeArgs = new RangedList<Type<?>>(null); |
| Position begin; |
| List<AnnotationExpr> annotations = null; |
| jj_consume_token(IDENTIFIER); |
| begin=tokenBegin(); |
| name = token.image; |
| if (jj_2_14(2)) { |
| typeArgs = TypeArguments(); |
| } else { |
| ; |
| } |
| ret = new ClassOrInterfaceType(range(begin, tokenEnd()),null, name, typeArgs.list); |
| label_25: |
| while (true) { |
| if (jj_2_15(2)) { |
| ; |
| } else { |
| break label_25; |
| } |
| jj_consume_token(DOT); |
| annotations = Annotations(); |
| jj_consume_token(IDENTIFIER); |
| name = token.image; |
| if (jj_2_16(2)) { |
| typeArgs = TypeArguments(); |
| } else { |
| ; |
| } |
| ret = new ClassOrInterfaceType(range(begin, tokenEnd()),ret, name, typeArgs.list); |
| ret.setAnnotations(annotations); |
| annotations = null; |
| } |
| return ret; |
| } |
| |
| final public RangedList<Type<?>> TypeArguments() {RangedList<Type<?>> ret = new RangedList<Type<?>>(new LinkedList<Type<?>>()); |
| Type type; |
| jj_consume_token(LT); |
| ret.beginAt(tokenBegin()); |
| 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: |
| 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[58] = jj_gen; |
| break label_26; |
| } |
| jj_consume_token(COMMA); |
| type = TypeArgument(); |
| ret.add(type); |
| } |
| break; |
| } |
| default: |
| jj_la1[59] = jj_gen; |
| ; |
| } |
| jj_consume_token(GT); |
| ret.endAt(tokenEnd()); |
| return ret; |
| } |
| |
| final public Type TypeArgument() {Type ret; |
| List<AnnotationExpr> annotations = null; |
| 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: |
| case IDENTIFIER:{ |
| ret = ReferenceType(); |
| break; |
| } |
| case HOOK:{ |
| ret = Wildcard(); |
| break; |
| } |
| default: |
| jj_la1[60] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret.setAnnotations(annotations); return ret; |
| } |
| |
| final public WildcardType Wildcard() {ReferenceType ext = null; |
| ReferenceType sup = null; |
| Position begin; |
| List<AnnotationExpr> annotations = null; |
| jj_consume_token(HOOK); |
| begin=tokenBegin(); |
| 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(); |
| ext.setAnnotations(annotations); |
| break; |
| } |
| case SUPER:{ |
| jj_consume_token(SUPER); |
| annotations = Annotations(); |
| sup = ReferenceType(); |
| sup.setAnnotations(annotations); |
| break; |
| } |
| default: |
| jj_la1[61] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| } |
| default: |
| jj_la1[62] = jj_gen; |
| ; |
| } |
| return new WildcardType(range(begin, tokenEnd()),ext, sup); |
| } |
| |
| final public PrimitiveType PrimitiveType() {PrimitiveType ret; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN:{ |
| jj_consume_token(BOOLEAN); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.Boolean); |
| break; |
| } |
| case CHAR:{ |
| jj_consume_token(CHAR); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.Char); |
| break; |
| } |
| case BYTE:{ |
| jj_consume_token(BYTE); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.Byte); |
| break; |
| } |
| case SHORT:{ |
| jj_consume_token(SHORT); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.Short); |
| break; |
| } |
| case INT:{ |
| jj_consume_token(INT); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.Int); |
| break; |
| } |
| case LONG:{ |
| jj_consume_token(LONG); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.Long); |
| break; |
| } |
| case FLOAT:{ |
| jj_consume_token(FLOAT); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.Float); |
| break; |
| } |
| case DOUBLE:{ |
| jj_consume_token(DOUBLE); |
| ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.Double); |
| break; |
| } |
| default: |
| jj_la1[63] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Type ResultType() {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 FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| case IDENTIFIER:{ |
| ret = Type(); |
| break; |
| } |
| default: |
| jj_la1[64] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public NameExpr Name() {NameExpr ret; |
| jj_consume_token(IDENTIFIER); |
| ret = new NameExpr(tokenRange(), token.image); |
| label_27: |
| while (true) { |
| if (jj_2_17(2)) { |
| ; |
| } else { |
| break label_27; |
| } |
| jj_consume_token(DOT); |
| jj_consume_token(IDENTIFIER); |
| ret = new QualifiedNameExpr(range(ret.getBegin(), pos(token.endLine, token.endColumn)), ret, token.image); |
| } |
| return ret; |
| } |
| |
| final public NameExpr SimpleName() {NameExpr ret; |
| jj_consume_token(IDENTIFIER); |
| ret = new NameExpr(tokenRange(), token.image); |
| return ret; |
| } |
| |
| /* |
| * Expression syntax follows. |
| */ |
| final public |
| Expression Expression() {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_18(2)) { |
| op = AssignmentOperator(); |
| value = Expression(); |
| ret = new AssignExpr(range(ret.getBegin(), pos(token.endLine, token.endColumn)), 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 IDENTIFIER:{ |
| jj_consume_token(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.getBegin(), pos(token.endLine, token.endColumn)), 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() {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.star; |
| break; |
| } |
| case SLASHASSIGN:{ |
| jj_consume_token(SLASHASSIGN); |
| ret = AssignExpr.Operator.slash; |
| break; |
| } |
| case REMASSIGN:{ |
| jj_consume_token(REMASSIGN); |
| ret = AssignExpr.Operator.rem; |
| 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.lShift; |
| break; |
| } |
| case RSIGNEDSHIFTASSIGN:{ |
| jj_consume_token(RSIGNEDSHIFTASSIGN); |
| ret = AssignExpr.Operator.rSignedShift; |
| break; |
| } |
| case RUNSIGNEDSHIFTASSIGN:{ |
| jj_consume_token(RUNSIGNEDSHIFTASSIGN); |
| ret = AssignExpr.Operator.rUnsignedShift; |
| break; |
| } |
| case ANDASSIGN:{ |
| jj_consume_token(ANDASSIGN); |
| ret = AssignExpr.Operator.and; |
| break; |
| } |
| case XORASSIGN:{ |
| jj_consume_token(XORASSIGN); |
| ret = AssignExpr.Operator.xor; |
| break; |
| } |
| case ORASSIGN:{ |
| jj_consume_token(ORASSIGN); |
| ret = AssignExpr.Operator.or; |
| break; |
| } |
| default: |
| jj_la1[69] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Expression ConditionalExpression() {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.getBegin(), pos(token.endLine, token.endColumn)), ret, left, right); |
| break; |
| } |
| default: |
| jj_la1[70] = jj_gen; |
| ; |
| } |
| return ret; |
| } |
| |
| final public Expression ConditionalOrExpression() {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.getBegin(), pos(token.endLine, token.endColumn)), ret, right, BinaryExpr.Operator.or); |
| } |
| return ret; |
| } |
| |
| final public Expression ConditionalAndExpression() {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.getBegin(), pos(token.endLine, token.endColumn)), ret, right, BinaryExpr.Operator.and); |
| } |
| return ret; |
| } |
| |
| final public Expression InclusiveOrExpression() {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.getBegin(), pos(token.endLine, token.endColumn)), ret, right, BinaryExpr.Operator.binOr); |
| } |
| return ret; |
| } |
| |
| final public Expression ExclusiveOrExpression() {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.getBegin(), pos(token.endLine, token.endColumn)), ret, right, BinaryExpr.Operator.xor); |
| } |
| return ret; |
| } |
| |
| final public Expression AndExpression() {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.getBegin(), pos(token.endLine, token.endColumn)), ret, right, BinaryExpr.Operator.binAnd); |
| } |
| return ret; |
| } |
| |
| final public Expression EqualityExpression() {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.notEquals; |
| break; |
| } |
| default: |
| jj_la1[77] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| right = InstanceOfExpression(); |
| ret = new BinaryExpr(range(ret.getBegin(), pos(token.endLine, token.endColumn)), ret, right, op); |
| } |
| return ret; |
| } |
| |
| final public Expression InstanceOfExpression() {Expression ret; |
| Type type; |
| ret = RelationalExpression(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case INSTANCEOF:{ |
| jj_consume_token(INSTANCEOF); |
| type = Type(); |
| ret = new InstanceOfExpr(range(ret.getBegin(), pos(token.endLine, token.endColumn)), ret, type); |
| break; |
| } |
| default: |
| jj_la1[78] = jj_gen; |
| ; |
| } |
| return ret; |
| } |
| |
| final public Expression RelationalExpression() {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.lessEquals; |
| break; |
| } |
| case GE:{ |
| jj_consume_token(GE); |
| op = BinaryExpr.Operator.greaterEquals; |
| break; |
| } |
| default: |
| jj_la1[80] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| right = ShiftExpression(); |
| ret = new BinaryExpr(range(ret.getBegin(), pos(token.endLine, token.endColumn)), ret, right, op); |
| } |
| return ret; |
| } |
| |
| final public Expression ShiftExpression() {Expression ret; |
| Expression right; |
| BinaryExpr.Operator op; |
| ret = AdditiveExpression(); |
| label_35: |
| while (true) { |
| if (jj_2_19(1)) { |
| ; |
| } else { |
| break label_35; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LSHIFT:{ |
| jj_consume_token(LSHIFT); |
| op = BinaryExpr.Operator.lShift; |
| break; |
| } |
| default: |
| jj_la1[81] = jj_gen; |
| if (jj_2_20(1)) { |
| RSIGNEDSHIFT(); |
| op = BinaryExpr.Operator.rSignedShift; |
| } else if (jj_2_21(1)) { |
| RUNSIGNEDSHIFT(); |
| op = BinaryExpr.Operator.rUnsignedShift; |
| } else { |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| right = AdditiveExpression(); |
| ret = new BinaryExpr(range(ret.getBegin(), pos(token.endLine, token.endColumn)), ret, right, op); |
| } |
| return ret; |
| } |
| |
| final public Expression AdditiveExpression() {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.getBegin(), pos(token.endLine, token.endColumn)), ret, right, op); |
| } |
| return ret; |
| } |
| |
| final public Expression MultiplicativeExpression() {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.times; |
| 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.getBegin(), tokenEnd()), ret, right, op); |
| } |
| return ret; |
| } |
| |
| final public Expression UnaryExpression() {Expression ret; |
| UnaryExpr.Operator op; |
| Position 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.positive; begin=tokenBegin(); |
| break; |
| } |
| case MINUS:{ |
| jj_consume_token(MINUS); |
| op = UnaryExpr.Operator.negative; begin=tokenBegin(); |
| break; |
| } |
| default: |
| jj_la1[86] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = UnaryExpression(); |
| if(op == UnaryExpr.Operator.negative) { |
| if (ret instanceof IntegerLiteralExpr && ((IntegerLiteralExpr)ret).isMinValue()) { |
| ret = new IntegerLiteralMinValueExpr(range(begin, tokenEnd())); |
| } else if (ret instanceof LongLiteralExpr && ((LongLiteralExpr)ret).isMinValue()) { |
| ret = new LongLiteralMinValueExpr(range(begin, tokenEnd())); |
| } else { |
| ret = new UnaryExpr(range(begin, tokenEnd()), ret, op); |
| } |
| } else { |
| ret = new UnaryExpr(range(begin, tokenEnd()), ret, op); |
| } |
| break; |
| } |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| 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() {Expression ret; |
| Position begin = INVALID; |
| jj_consume_token(INCR); |
| begin=tokenBegin(); |
| ret = UnaryExpression(); |
| ret = new UnaryExpr(range(begin, tokenEnd()), ret, UnaryExpr.Operator.preIncrement); |
| return ret; |
| } |
| |
| final public Expression PreDecrementExpression() {Expression ret; |
| Position begin; |
| jj_consume_token(DECR); |
| begin=tokenBegin(); |
| ret = UnaryExpression(); |
| ret = new UnaryExpr(range(begin, tokenEnd()), ret, UnaryExpr.Operator.preDecrement); |
| return ret; |
| } |
| |
| final public Expression UnaryExpressionNotPlusMinus() {Expression ret; |
| UnaryExpr.Operator op; |
| Position 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.inverse; begin=tokenBegin(); |
| break; |
| } |
| case BANG:{ |
| jj_consume_token(BANG); |
| op = UnaryExpr.Operator.not; begin=tokenBegin(); |
| break; |
| } |
| default: |
| jj_la1[88] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = UnaryExpression(); |
| ret = new UnaryExpr(range(begin, tokenEnd()), ret, op); |
| break; |
| } |
| default: |
| jj_la1[89] = jj_gen; |
| if (jj_2_22(2147483647)) { |
| ret = CastExpression(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN:{ |
| ret = PostfixExpression(); |
| break; |
| } |
| default: |
| jj_la1[90] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| final public Expression PostfixExpression() {Expression ret; |
| UnaryExpr.Operator op; |
| ret = PrimaryExpression(); |
| if (jj_2_23(2)) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case INCR:{ |
| jj_consume_token(INCR); |
| op = UnaryExpr.Operator.posIncrement; |
| break; |
| } |
| case DECR:{ |
| jj_consume_token(DECR); |
| op = UnaryExpr.Operator.posDecrement; |
| break; |
| } |
| default: |
| jj_la1[91] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = new UnaryExpr(range(ret.getBegin(), pos(token.endLine, token.endColumn)), ret, op); |
| } else { |
| ; |
| } |
| return ret; |
| } |
| |
| final public Expression CastExpression() {Expression ret; |
| ReferenceType referenceType; |
| PrimitiveType primitiveType; |
| Position begin = INVALID; |
| List<AnnotationExpr> annotations = null; |
| List<ReferenceType> typesOfMultiCast = null; |
| jj_consume_token(LPAREN); |
| begin=tokenBegin(); |
| annotations = Annotations(); |
| if (jj_2_24(2)) { |
| primitiveType = PrimitiveType(); |
| jj_consume_token(RPAREN); |
| ret = UnaryExpression(); |
| primitiveType.setAnnotations(annotations); ret = new CastExpr(range(begin, tokenEnd()), primitiveType, ret); |
| } 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: |
| case IDENTIFIER:{ |
| referenceType = ReferenceType(); |
| typesOfMultiCast = add(typesOfMultiCast, referenceType); referenceType.setAnnotations(annotations); |
| 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 = ReferenceType(); |
| typesOfMultiCast = add(typesOfMultiCast, referenceType); |
| } |
| jj_consume_token(RPAREN); |
| ret = UnaryExpressionNotPlusMinus(); |
| if (typesOfMultiCast.size() > 1) { |
| ret = new CastExpr(range(begin, tokenEnd()), new IntersectionType(range(begin, tokenEnd()), typesOfMultiCast), ret); |
| } |
| ret = new CastExpr(range(begin, tokenEnd()), referenceType, ret); |
| break; |
| } |
| default: |
| jj_la1[93] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public Expression PrimaryExpression() {Expression ret; |
| ret = PrimaryPrefix(); |
| label_39: |
| while (true) { |
| if (jj_2_25(2)) { |
| ; |
| } else { |
| break label_39; |
| } |
| ret = PrimarySuffix(ret); |
| } |
| return ret; |
| } |
| |
| final public Expression PrimaryExpressionWithoutSuperSuffix() {Expression ret; |
| ret = PrimaryPrefix(); |
| label_40: |
| while (true) { |
| if (jj_2_26(2147483647)) { |
| ; |
| } else { |
| break label_40; |
| } |
| ret = PrimarySuffixWithoutSuper(ret); |
| } |
| return ret; |
| } |
| |
| final public Expression PrimaryPrefix() {Expression ret = null; |
| NameExpr name; |
| RangedList<Type<?>> typeArgs = new RangedList<Type<?>>(null); |
| List<Expression> args = null; |
| List<Parameter> params = null; |
| boolean hasArgs = false; |
| boolean isLambda = false; |
| Type type; |
| Position begin; |
| Parameter p = null; |
| VariableDeclaratorId 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) { |
| MethodCallExpr m = new MethodCallExpr(range(ret.getBegin(), pos(token.endLine, token.endColumn)), ret, typeArgs.list, null, args); |
| m.setNameExpr(name); |
| ret = m; |
| } else { |
| FieldAccessExpr f = new FieldAccessExpr(range(ret.getBegin(), pos(token.endLine, token.endColumn)), ret, null, null); |
| f.setFieldExpr(name); |
| ret = f; |
| } |
| 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 IDENTIFIER:{ |
| jj_consume_token(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.getBegin(), pos(token.endLine, token.endColumn)), 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=tokenBegin(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| 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 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:{ |
| if (jj_2_27(2147483647)) { |
| p = FormalParameter(); |
| isLambda = true; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| params = FormalLambdaParameters(); |
| break; |
| } |
| default: |
| jj_la1[99] = jj_gen; |
| ; |
| } |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| ret = Expression(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| params = InferredLambdaParameters(); |
| isLambda = true; |
| break; |
| } |
| default: |
| jj_la1[100] = jj_gen; |
| ; |
| } |
| break; |
| } |
| default: |
| jj_la1[101] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| break; |
| } |
| default: |
| jj_la1[102] = jj_gen; |
| ; |
| } |
| jj_consume_token(RPAREN); |
| if(!isLambda) { ret = new EnclosedExpr(range(begin, tokenEnd()), ret);} |
| else{ |
| if(ret != null){ |
| if(ret instanceof NameExpr) |
| { |
| id = new VariableDeclaratorId(range(ret.getBegin(), ret.getEnd()), ((NameExpr)ret).getName(), null); |
| p = new Parameter(range(ret.getBegin(), ret.getEnd()), EnumSet.noneOf(Modifier.class), null, new UnknownType(), null, false, id); |
| } |
| |
| } |
| params = add(0, params, p); |
| // TODO p may be null here |
| ret = new LambdaExpr(range(p.getBegin(), tokenEnd()), params, null, true); |
| } |
| break; |
| } |
| case NEW:{ |
| ret = AllocationExpression(null); |
| break; |
| } |
| default: |
| jj_la1[106] = jj_gen; |
| if (jj_2_28(2147483647)) { |
| type = ResultType(); |
| jj_consume_token(DOT); |
| jj_consume_token(CLASS); |
| ret = new ClassExpr(range(type.getBegin(), tokenEnd()), type); |
| } else if (jj_2_29(2147483647)) { |
| type = ResultType(); |
| jj_consume_token(DOUBLECOLON); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| break; |
| } |
| default: |
| jj_la1[103] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IDENTIFIER:{ |
| jj_consume_token(IDENTIFIER); |
| break; |
| } |
| case NEW:{ |
| jj_consume_token(NEW); |
| break; |
| } |
| default: |
| jj_la1[104] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| ret = new TypeExpr(type.getRange(), type); |
| ret = new MethodReferenceExpr(ret.getRange(), ret, typeArgs.list, token.image); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IDENTIFIER:{ |
| name = SimpleName(); |
| begin=tokenBegin(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LPAREN:{ |
| args = Arguments(); |
| hasArgs=true; |
| break; |
| } |
| default: |
| jj_la1[105] = jj_gen; |
| ; |
| } |
| if (hasArgs) { |
| MethodCallExpr m = new MethodCallExpr(range(begin, tokenEnd()), null, null, null, args); |
| m.setNameExpr(name); |
| ret = m; |
| } else { |
| ret = name; |
| } |
| break; |
| } |
| default: |
| jj_la1[107] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| final public Expression PrimarySuffix(Expression scope) {Expression ret; |
| if (jj_2_30(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.getBegin(), tokenEnd()), scope); |
| break; |
| } |
| default: |
| jj_la1[108] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public Expression PrimarySuffixWithoutSuper(Expression scope) {Expression ret; |
| RangedList<Type<?>> typeArgs = new RangedList<Type<?>>(null); |
| List<Expression> args = null; |
| boolean hasArgs = false; |
| NameExpr 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.getBegin(), tokenEnd()), scope); |
| break; |
| } |
| case NEW:{ |
| ret = AllocationExpression(scope); |
| break; |
| } |
| default: |
| jj_la1[111] = jj_gen; |
| if (jj_2_31(2147483647)) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| break; |
| } |
| default: |
| jj_la1[109] = jj_gen; |
| ; |
| } |
| name = SimpleName(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LPAREN:{ |
| args = Arguments(); |
| hasArgs=true; |
| break; |
| } |
| default: |
| jj_la1[110] = jj_gen; |
| ; |
| } |
| if (hasArgs) { |
| MethodCallExpr m = new MethodCallExpr(range(scope.getBegin(), tokenEnd()), scope, typeArgs.list, null, args); |
| m.setNameExpr(name); |
| ret = m; |
| } else { |
| FieldAccessExpr f = new FieldAccessExpr(range(scope.getBegin(), tokenEnd()), scope, typeArgs.list, null); |
| f.setFieldExpr(name); |
| ret = f; |
| } |
| } 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.getBegin(), tokenEnd()), scope, ret); |
| break; |
| } |
| default: |
| jj_la1[112] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Expression Literal() {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[113] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Expression BooleanLiteral() {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[114] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Expression NullLiteral() { |
| jj_consume_token(NULL); |
| return new NullLiteralExpr(tokenRange()); |
| } |
| |
| final public List<Expression> Arguments() {List<Expression> ret = null; |
| jj_consume_token(LPAREN); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| ret = ArgumentList(); |
| break; |
| } |
| default: |
| jj_la1[115] = jj_gen; |
| ; |
| } |
| jj_consume_token(RPAREN); |
| return ret; |
| } |
| |
| final public List<Expression> ArgumentList() {List<Expression> ret = new LinkedList<Expression>(); |
| 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[116] = jj_gen; |
| break label_41; |
| } |
| jj_consume_token(COMMA); |
| expr = Expression(); |
| ret.add(expr); |
| } |
| return ret; |
| } |
| |
| final public Expression AllocationExpression(Expression scope) {Expression ret; |
| Type type; |
| RangedList<Type<?>> typeArgs = new RangedList<Type<?>>(null); |
| List<BodyDeclaration<?>> anonymousBody = null; |
| List<Expression> args; |
| Position begin; |
| List<AnnotationExpr> annotations = null; |
| jj_consume_token(NEW); |
| if(scope==null) {begin=tokenBegin();} else {begin=scope.getBegin();} |
| 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(); |
| type.setAnnotations(annotations); |
| ret = ArrayCreation(begin, type); |
| break; |
| } |
| case IDENTIFIER: |
| case AT: |
| case LT:{ |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| annotations = Annotations(); |
| break; |
| } |
| default: |
| jj_la1[117] = 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_32(2)) { |
| anonymousBody = ClassOrInterfaceBody(false); |
| } else { |
| ; |
| } |
| ret = new ObjectCreationExpr(range(begin, tokenEnd()), scope, (ClassOrInterfaceType) type, typeArgs.list, args, anonymousBody); |
| break; |
| } |
| default: |
| jj_la1[118] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| } |
| default: |
| jj_la1[119] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| /* |
| * The third LOOKAHEAD specification below is to parse to PrimarySuffix |
| * if there is an expression between the "[...]". |
| */ |
| final public ArrayCreationExpr ArrayCreation(Position begin, Type type) {Expression expr = null; |
| ArrayInitializerExpr arrayInitializerExpr = null; |
| List<Expression> inits = null; |
| List<List<AnnotationExpr>> accum = null; |
| List<AnnotationExpr> annotations = null; |
| label_42: |
| while (true) { |
| annotations = Annotations(); |
| jj_consume_token(LBRACKET); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| expr = Expression(); |
| break; |
| } |
| default: |
| jj_la1[120] = jj_gen; |
| ; |
| } |
| accum = add(accum, annotations); inits = add(inits, expr); annotations=null; expr=null; |
| jj_consume_token(RBRACKET); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACKET: |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[121] = jj_gen; |
| break label_42; |
| } |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LBRACE:{ |
| arrayInitializerExpr = ArrayInitializer(); |
| break; |
| } |
| default: |
| jj_la1[122] = jj_gen; |
| ; |
| } |
| return juggleArrayCreation(range(begin, tokenEnd()), type, inits, accum, arrayInitializerExpr); |
| } |
| |
| /* |
| * Statement syntax follows. |
| */ |
| final public |
| Statement Statement() {Statement ret; |
| if (jj_2_33(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 FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| 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[123] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public AssertStmt AssertStatement() {Expression check; |
| Expression msg = null; |
| Position begin; |
| jj_consume_token(ASSERT); |
| begin=tokenBegin(); |
| check = Expression(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COLON:{ |
| jj_consume_token(COLON); |
| msg = Expression(); |
| break; |
| } |
| default: |
| jj_la1[124] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| return new AssertStmt(range(begin, tokenEnd()),check, msg); |
| } |
| |
| final public LabeledStmt LabeledStatement() {String label; |
| Statement stmt; |
| Position begin; |
| jj_consume_token(IDENTIFIER); |
| begin=tokenBegin(); |
| label = token.image; |
| jj_consume_token(COLON); |
| stmt = Statement(); |
| return new LabeledStmt(range(begin, tokenEnd()),label, stmt); |
| } |
| |
| final public BlockStmt Block() {List<Statement> stmts; |
| Position begin; |
| jj_consume_token(LBRACE); |
| begin=tokenBegin(); |
| stmts = Statements(); |
| jj_consume_token(RBRACE); |
| return new BlockStmt(range(begin, tokenEnd()), stmts); |
| } |
| |
| /* |
| * Classes inside block stametents can only be abstract or final. The semantic must check it. |
| */ |
| final public Statement BlockStatement() {Statement ret; |
| Expression expr; |
| ClassOrInterfaceDeclaration typeDecl; |
| ModifierHolder modifier; |
| if (jj_2_34(2147483647)) { |
| |
| modifier = Modifiers(); |
| typeDecl = ClassOrInterfaceDeclaration(modifier); |
| ret = new TypeDeclarationStmt(range(typeDecl.getBegin().line, typeDecl.getBegin().column, token.endLine, token.endColumn), typeDecl); |
| } else if (jj_2_35(2147483647)) { |
| expr = VariableDeclarationExpression(); |
| jj_consume_token(SEMICOLON); |
| ret = new ExpressionStmt(range(expr.getBegin().line, expr.getBegin().column, token.endLine, token.endColumn), 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 FALSE: |
| case FLOAT: |
| case FOR: |
| case IF: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case RETURN: |
| case SHORT: |
| case SUPER: |
| case SWITCH: |
| case SYNCHRONIZED: |
| case THIS: |
| case THROW: |
| case TRUE: |
| case TRY: |
| case VOID: |
| case WHILE: |
| 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 INCR: |
| case DECR:{ |
| ret = Statement(); |
| break; |
| } |
| default: |
| jj_la1[125] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public VariableDeclarationExpr VariableDeclarationExpression() {ModifierHolder modifier; |
| Type type; |
| List<VariableDeclarator> variables = new LinkedList<VariableDeclarator>(); |
| VariableDeclarator var; |
| modifier = Modifiers(); |
| type = Type(); |
| var = VariableDeclarator(); |
| variables.add(var); |
| label_43: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[126] = jj_gen; |
| break label_43; |
| } |
| jj_consume_token(COMMA); |
| var = VariableDeclarator(); |
| variables.add(var); |
| } |
| Position begin=modifier.begin.orIfInvalid(type.getBegin()); |
| Pair<Type, List<ArrayBracketPair>> typeListPair = unwrapArrayTypes(type); |
| return new VariableDeclarationExpr(range(begin, tokenEnd()), modifier.modifiers, modifier.annotations, typeListPair.a, variables, typeListPair.b); |
| } |
| |
| final public EmptyStmt EmptyStatement() { |
| jj_consume_token(SEMICOLON); |
| return new EmptyStmt(tokenRange()); |
| } |
| |
| final public Statement LambdaBody() {Expression expr; |
| Statement n = null; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| expr = Expression(); |
| n = new ExpressionStmt(range(expr.getBegin(), tokenEnd()), expr); |
| break; |
| } |
| case LBRACE:{ |
| n = Block(); |
| break; |
| } |
| default: |
| jj_la1[127] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return n; |
| } |
| |
| final public ExpressionStmt StatementExpression() {Expression expr; |
| AssignExpr.Operator op; |
| Expression value; |
| RangedList<Type<?>> typeArgs = new RangedList<Type<?>>(null); |
| Statement lambdaBody; |
| if (jj_2_36(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 FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN:{ |
| 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: |
| case ARROW: |
| case DOUBLECOLON:{ |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case INCR:{ |
| jj_consume_token(INCR); |
| expr = new UnaryExpr(range(expr.getBegin(), tokenEnd()), expr, UnaryExpr.Operator.posIncrement); |
| break; |
| } |
| case DECR:{ |
| jj_consume_token(DECR); |
| expr = new UnaryExpr(range(expr.getBegin(), tokenEnd()), expr, UnaryExpr.Operator.posDecrement); |
| 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.getBegin(), tokenEnd()), expr, value, op); |
| break; |
| } |
| case DOUBLECOLON:{ |
| jj_consume_token(DOUBLECOLON); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LT:{ |
| typeArgs = TypeArguments(); |
| break; |
| } |
| default: |
| jj_la1[128] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IDENTIFIER:{ |
| jj_consume_token(IDENTIFIER); |
| break; |
| } |
| case NEW:{ |
| jj_consume_token(NEW); |
| break; |
| } |
| default: |
| jj_la1[129] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| expr = new MethodReferenceExpr(range(expr.getBegin(), tokenEnd()), expr, typeArgs.list, token.image); |
| break; |
| } |
| case ARROW:{ |
| jj_consume_token(ARROW); |
| lambdaBody = LambdaBody(); |
| expr = generateLambda(expr, lambdaBody); |
| break; |
| } |
| default: |
| jj_la1[130] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| } |
| default: |
| jj_la1[131] = jj_gen; |
| ; |
| } |
| break; |
| } |
| default: |
| jj_la1[132] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| jj_consume_token(SEMICOLON); |
| return new ExpressionStmt(range(expr.getBegin(), tokenEnd()), expr); |
| } |
| |
| final public SwitchStmt SwitchStatement() {Expression selector; |
| SwitchEntryStmt entry; |
| List<SwitchEntryStmt> entries = null; |
| Position begin; |
| jj_consume_token(SWITCH); |
| begin=tokenBegin(); |
| 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[133] = jj_gen; |
| break label_44; |
| } |
| entry = SwitchEntry(); |
| entries = add(entries, entry); |
| } |
| jj_consume_token(RBRACE); |
| return new SwitchStmt(range(begin, tokenEnd()), selector, entries); |
| } |
| |
| final public SwitchEntryStmt SwitchEntry() {Expression label = null; |
| List<Statement> stmts; |
| Position begin; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CASE:{ |
| jj_consume_token(CASE); |
| begin=tokenBegin(); |
| label = Expression(); |
| break; |
| } |
| case _DEFAULT:{ |
| jj_consume_token(_DEFAULT); |
| begin=tokenBegin(); |
| break; |
| } |
| default: |
| jj_la1[134] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jj_consume_token(COLON); |
| stmts = Statements(); |
| return new SwitchEntryStmt(range(begin, tokenEnd()),label, stmts); |
| } |
| |
| final public IfStmt IfStatement() {Expression condition; |
| Statement thenStmt; |
| Statement elseStmt = null; |
| Position begin; |
| Comment thenCmmt = null; |
| Comment elseCmmt = null; |
| jj_consume_token(IF); |
| begin=tokenBegin(); |
| 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[135] = jj_gen; |
| ; |
| } |
| IfStmt tmp = new IfStmt(range(begin, tokenEnd()),condition, thenStmt, elseStmt); |
| |
| // TODO comment is always null |
| thenStmt.setComment(thenCmmt); |
| if (elseStmt != null) |
| // TODO comment is always null |
| elseStmt.setComment(elseCmmt); |
| return tmp; |
| } |
| |
| final public WhileStmt WhileStatement() {Expression condition; |
| Statement body; |
| Position begin; |
| jj_consume_token(WHILE); |
| begin=tokenBegin(); |
| jj_consume_token(LPAREN); |
| condition = Expression(); |
| jj_consume_token(RPAREN); |
| body = Statement(); |
| return new WhileStmt(range(begin, tokenEnd()),condition, body); |
| } |
| |
| final public DoStmt DoStatement() {Expression condition; |
| Statement body; |
| Position begin; |
| jj_consume_token(DO); |
| begin=tokenBegin(); |
| 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, tokenEnd()),body, condition); |
| } |
| |
| final public Statement ForStatement() {VariableDeclarationExpr varExpr = null; |
| Expression expr = null; |
| List<Expression> init = null; |
| List<Expression> update = null; |
| Statement body; |
| Position begin; |
| jj_consume_token(FOR); |
| begin=tokenBegin(); |
| jj_consume_token(LPAREN); |
| if (jj_2_37(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 DOUBLE: |
| 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 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 DOUBLE: |
| 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 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[136] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| expr = Expression(); |
| break; |
| } |
| default: |
| jj_la1[137] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| update = ForUpdate(); |
| break; |
| } |
| default: |
| jj_la1[138] = jj_gen; |
| ; |
| } |
| break; |
| } |
| default: |
| jj_la1[139] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| jj_consume_token(RPAREN); |
| body = Statement(); |
| if (varExpr != null) { |
| return new ForeachStmt(range(begin, tokenEnd()),varExpr, expr, body); |
| } |
| return new ForStmt(range(begin, tokenEnd()),init, expr, update, body); |
| } |
| |
| final public List<Expression> ForInit() {List<Expression> ret; |
| Expression expr; |
| if (jj_2_38(2147483647)) { |
| expr = VariableDeclarationExpression(); |
| ret = new LinkedList<Expression>(); ret.add(expr); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| ret = ExpressionList(); |
| break; |
| } |
| default: |
| jj_la1[140] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public List<Expression> ExpressionList() {List<Expression> ret = new LinkedList<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[141] = jj_gen; |
| break label_45; |
| } |
| jj_consume_token(COMMA); |
| expr = Expression(); |
| ret.add(expr); |
| } |
| return ret; |
| } |
| |
| final public List<Expression> ForUpdate() {List<Expression> ret; |
| ret = ExpressionList(); |
| return ret; |
| } |
| |
| final public BreakStmt BreakStatement() {String id = null; |
| Position begin; |
| jj_consume_token(BREAK); |
| begin=tokenBegin(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IDENTIFIER:{ |
| jj_consume_token(IDENTIFIER); |
| id = token.image; |
| break; |
| } |
| default: |
| jj_la1[142] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| return new BreakStmt(range(begin, tokenEnd()),id); |
| } |
| |
| final public ContinueStmt ContinueStatement() {String id = null; |
| Position begin; |
| jj_consume_token(CONTINUE); |
| begin=tokenBegin(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IDENTIFIER:{ |
| jj_consume_token(IDENTIFIER); |
| id = token.image; |
| break; |
| } |
| default: |
| jj_la1[143] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| return new ContinueStmt(range(begin, tokenEnd()),id); |
| } |
| |
| final public ReturnStmt ReturnStatement() {Expression expr = null; |
| Position begin; |
| jj_consume_token(RETURN); |
| begin=tokenBegin(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| expr = Expression(); |
| break; |
| } |
| default: |
| jj_la1[144] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| return new ReturnStmt(range(begin, tokenEnd()),expr); |
| } |
| |
| final public ThrowStmt ThrowStatement() {Expression expr; |
| Position begin; |
| jj_consume_token(THROW); |
| begin=tokenBegin(); |
| expr = Expression(); |
| jj_consume_token(SEMICOLON); |
| return new ThrowStmt(range(begin, tokenEnd()),expr); |
| } |
| |
| final public SynchronizedStmt SynchronizedStatement() {Expression expr; |
| BlockStmt block; |
| Position begin; |
| jj_consume_token(SYNCHRONIZED); |
| begin=tokenBegin(); |
| jj_consume_token(LPAREN); |
| expr = Expression(); |
| jj_consume_token(RPAREN); |
| block = Block(); |
| return new SynchronizedStmt(range(begin, tokenEnd()),expr, block); |
| } |
| |
| final public TryStmt TryStatement() {List<VariableDeclarationExpr> resources = null; |
| BlockStmt tryBlock; |
| BlockStmt finallyBlock = null; |
| List<CatchClause> catchs = null; |
| BlockStmt catchBlock; |
| ModifierHolder exceptModifier; |
| ReferenceType exceptionType; |
| List<ReferenceType> exceptionTypes = new LinkedList<ReferenceType>(); |
| VariableDeclaratorId exceptId; |
| Position begin; |
| Position catchBegin; |
| Type type; |
| jj_consume_token(TRY); |
| begin=tokenBegin(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case LPAREN:{ |
| resources = ResourceSpecification(); |
| break; |
| } |
| default: |
| jj_la1[145] = jj_gen; |
| ; |
| } |
| tryBlock = Block(); |
| label_46: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CATCH:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[146] = jj_gen; |
| break label_46; |
| } |
| jj_consume_token(CATCH); |
| catchBegin=tokenBegin(); |
| jj_consume_token(LPAREN); |
| exceptModifier = Modifiers(); |
| exceptionType = ReferenceType(); |
| exceptionTypes.add(exceptionType); |
| label_47: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BIT_OR:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[147] = jj_gen; |
| break label_47; |
| } |
| jj_consume_token(BIT_OR); |
| exceptionType = ReferenceTypeWithAnnotations(); |
| exceptionTypes.add(exceptionType); |
| } |
| exceptId = VariableDeclaratorId(); |
| jj_consume_token(RPAREN); |
| catchBlock = Block(); |
| if (exceptionTypes.size() > 1) { |
| type = new UnionType(exceptionTypes); |
| } else { |
| type = (Type)exceptionTypes.get(0); |
| } |
| catchs = add(catchs, new CatchClause(range(catchBegin, tokenEnd()), exceptModifier.modifiers, exceptModifier.annotations, type, exceptId, catchBlock)); |
| exceptionTypes = new LinkedList<ReferenceType>(); |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case FINALLY:{ |
| jj_consume_token(FINALLY); |
| finallyBlock = Block(); |
| break; |
| } |
| default: |
| jj_la1[148] = jj_gen; |
| ; |
| } |
| if (finallyBlock==null && catchs==null && resources==null) { |
| addProblem("Try has no finally, no catch, and no resources"); |
| } |
| return new TryStmt(range(begin, tokenEnd()), resources, tryBlock, catchs, finallyBlock); |
| } |
| |
| final public List<VariableDeclarationExpr> ResourceSpecification() {List<VariableDeclarationExpr> variables; |
| jj_consume_token(LPAREN); |
| variables = Resources(); |
| if (jj_2_39(2)) { |
| jj_consume_token(SEMICOLON); |
| } else { |
| ; |
| } |
| jj_consume_token(RPAREN); |
| return variables; |
| } |
| |
| final public List<VariableDeclarationExpr> Resources() {List<VariableDeclarationExpr> variables = new LinkedList<VariableDeclarationExpr>(); |
| VariableDeclarationExpr var; |
| /*this is a bit more lenient than we need to be, eg allowing access modifiers like private*/ |
| var = VariableDeclarationExpression(); |
| variables.add(var); |
| label_48: |
| while (true) { |
| if (jj_2_40(2)) { |
| ; |
| } else { |
| break label_48; |
| } |
| jj_consume_token(SEMICOLON); |
| var = VariableDeclarationExpression(); |
| variables.add(var); |
| } |
| return variables; |
| } |
| |
| /* We use productions to match >>>, >> and > so that we can keep the |
| * type declaration syntax with generics clean |
| */ |
| final public |
| void RUNSIGNEDSHIFT() { |
| if (getToken(1).kind == GT && |
| ((GTToken)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() { |
| if (getToken(1).kind == GT && |
| ((GTToken)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 |
| List<AnnotationExpr> Annotations() {List<AnnotationExpr> annotations = null; |
| AnnotationExpr annotation; |
| label_49: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[149] = jj_gen; |
| break label_49; |
| } |
| annotation = Annotation(); |
| annotations = add(annotations, annotation); |
| } |
| return annotations; |
| } |
| |
| final public AnnotationExpr Annotation() {AnnotationExpr ret; |
| if (jj_2_41(2147483647)) { |
| ret = NormalAnnotation(); |
| } else if (jj_2_42(2147483647)) { |
| ret = SingleMemberAnnotation(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case AT:{ |
| ret = MarkerAnnotation(); |
| break; |
| } |
| default: |
| jj_la1[150] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| return ret; |
| } |
| |
| final public NormalAnnotationExpr NormalAnnotation() {NameExpr name; |
| List<MemberValuePair> pairs = null; |
| Position begin; |
| jj_consume_token(AT); |
| begin=tokenBegin(); |
| name = Name(); |
| jj_consume_token(LPAREN); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case IDENTIFIER:{ |
| pairs = MemberValuePairs(); |
| break; |
| } |
| default: |
| jj_la1[151] = jj_gen; |
| ; |
| } |
| jj_consume_token(RPAREN); |
| return new NormalAnnotationExpr(range(begin, tokenEnd()),name, pairs); |
| } |
| |
| final public MarkerAnnotationExpr MarkerAnnotation() {NameExpr name; |
| Position begin; |
| jj_consume_token(AT); |
| begin=tokenBegin(); |
| name = Name(); |
| return new MarkerAnnotationExpr(range(begin, tokenEnd()),name); |
| } |
| |
| final public SingleMemberAnnotationExpr SingleMemberAnnotation() {NameExpr name; |
| Expression memberVal; |
| Position begin; |
| jj_consume_token(AT); |
| begin=tokenBegin(); |
| name = Name(); |
| jj_consume_token(LPAREN); |
| memberVal = MemberValue(); |
| jj_consume_token(RPAREN); |
| return new SingleMemberAnnotationExpr(range(begin, tokenEnd()),name, memberVal); |
| } |
| |
| final public List<MemberValuePair> MemberValuePairs() {List<MemberValuePair> ret = new LinkedList<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[152] = jj_gen; |
| break label_50; |
| } |
| jj_consume_token(COMMA); |
| pair = MemberValuePair(); |
| ret.add(pair); |
| } |
| return ret; |
| } |
| |
| final public MemberValuePair MemberValuePair() {String name; |
| Expression value; |
| Position begin; |
| jj_consume_token(IDENTIFIER); |
| name = token.image; begin=tokenBegin(); |
| jj_consume_token(ASSIGN); |
| value = MemberValue(); |
| return new MemberValuePair(range(begin, tokenEnd()),name, value); |
| } |
| |
| final public Expression MemberValue() {Expression ret; |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case AT:{ |
| ret = Annotation(); |
| break; |
| } |
| case LBRACE:{ |
| ret = MemberValueArrayInitializer(); |
| break; |
| } |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| case LONG_LITERAL: |
| case INTEGER_LITERAL: |
| case FLOATING_POINT_LITERAL: |
| case CHARACTER_LITERAL: |
| case STRING_LITERAL: |
| case IDENTIFIER: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case INCR: |
| case DECR: |
| case PLUS: |
| case MINUS:{ |
| ret = ConditionalExpression(); |
| break; |
| } |
| default: |
| jj_la1[153] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public Expression MemberValueArrayInitializer() {List<Expression> ret = new LinkedList<Expression>(); |
| Expression member; |
| Position begin; |
| jj_consume_token(LBRACE); |
| begin=tokenBegin(); |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FALSE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case NULL: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case TRUE: |
| case VOID: |
| 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_43(2)) { |
| ; |
| } else { |
| break label_51; |
| } |
| jj_consume_token(COMMA); |
| member = MemberValue(); |
| ret.add(member); |
| } |
| break; |
| } |
| default: |
| jj_la1[154] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case COMMA:{ |
| jj_consume_token(COMMA); |
| break; |
| } |
| default: |
| jj_la1[155] = jj_gen; |
| ; |
| } |
| jj_consume_token(RBRACE); |
| return new ArrayInitializerExpr(range(begin, tokenEnd()),ret); |
| } |
| |
| /* Annotation Types. */ |
| final public |
| AnnotationDeclaration AnnotationTypeDeclaration(ModifierHolder modifier) {NameExpr name; |
| List<BodyDeclaration<?>> members; |
| Position begin = modifier.begin; |
| jj_consume_token(AT); |
| begin=begin.orIfInvalid(tokenBegin()); |
| jj_consume_token(INTERFACE); |
| name = Name(); |
| members = AnnotationTypeBody(); |
| AnnotationDeclaration tmp = new AnnotationDeclaration(range(begin, tokenEnd()), modifier.modifiers, modifier.annotations, null, members); |
| tmp.setNameExpr(name); |
| return tmp; |
| } |
| |
| final public List<BodyDeclaration<?>> AnnotationTypeBody() {List<BodyDeclaration<?>> ret = null; |
| 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 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 IDENTIFIER: |
| case SEMICOLON: |
| case AT:{ |
| ; |
| break; |
| } |
| default: |
| jj_la1[156] = jj_gen; |
| break label_52; |
| } |
| member = AnnotationBodyDeclaration(); |
| ret = add(ret, member); |
| } |
| jj_consume_token(RBRACE); |
| return ret; |
| } |
| |
| final public BodyDeclaration<?> AnnotationBodyDeclaration() {ModifierHolder modifier; |
| BodyDeclaration ret; |
| |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case SEMICOLON:{ |
| jj_consume_token(SEMICOLON); |
| ret = new EmptyTypeDeclaration(tokenRange()); |
| break; |
| } |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case CLASS: |
| 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 IDENTIFIER: |
| case AT:{ |
| modifier = Modifiers(); |
| if (jj_2_44(2147483647)) { |
| ret = AnnotationTypeMemberDeclaration(modifier); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { |
| case CLASS: |
| case INTERFACE:{ |
| ret = ClassOrInterfaceDeclaration(modifier); |
| break; |
| } |
| case ENUM:{ |
| ret = EnumDeclaration(modifier); |
| break; |
| } |
| case AT:{ |
| ret = AnnotationTypeDeclaration(modifier); |
| break; |
| } |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| case IDENTIFIER:{ |
| ret = FieldDeclaration(modifier); |
| break; |
| } |
| default: |
| jj_la1[157] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| break; |
| } |
| default: |
| jj_la1[158] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| return ret; |
| } |
| |
| final public AnnotationMemberDeclaration AnnotationTypeMemberDeclaration(ModifierHolder modifier) {Type type; |
| String name; |
| Expression defaultVal = null; |
| type = Type(); |
| jj_consume_token(IDENTIFIER); |
| name = token.image; |
| 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[159] = jj_gen; |
| ; |
| } |
| jj_consume_token(SEMICOLON); |
| Position begin = modifier.begin.orIfInvalid(tokenBegin()); |
| return new AnnotationMemberDeclaration(range(begin, tokenEnd()), modifier.modifiers, modifier.annotations, type, name, defaultVal); |
| } |
| |
| final public Expression DefaultValue() {Expression ret; |
| jj_consume_token(_DEFAULT); |
| ret = MemberValue(); |
| 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_3_38() |
| { |
| if (jj_3R_95()) return true; |
| if (jj_3R_68()) return true; |
| if (jj_scan_token(IDENTIFIER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_341() |
| { |
| if (jj_3R_345()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_373()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_385() |
| { |
| if (jj_scan_token(ELSE)) return true; |
| if (jj_3R_277()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_377() |
| { |
| if (jj_3R_93()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_427() |
| { |
| if (jj_3R_80()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_429()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_159() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_78()) return true; |
| if (jj_3R_158()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_21() |
| { |
| if (jj_3R_83()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_20() |
| { |
| if (jj_3R_82()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_426() |
| { |
| if (jj_3R_427()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_81() |
| { |
| if (jj_scan_token(LSHIFT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_402() |
| { |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_103() |
| { |
| if (jj_scan_token(LT)) return true; |
| if (jj_3R_78()) return true; |
| if (jj_3R_158()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_159()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(GT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_19() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_81()) { |
| jj_scanpos = xsp; |
| if (jj_3_20()) { |
| jj_scanpos = xsp; |
| if (jj_3_21()) return true; |
| } |
| } |
| if (jj_3R_341()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_425() |
| { |
| if (jj_3R_96()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_342() |
| { |
| if (jj_scan_token(INSTANCEOF)) return true; |
| if (jj_3R_68()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_339() |
| { |
| if (jj_3R_341()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_19()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_419() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_425()) { |
| jj_scanpos = xsp; |
| if (jj_3R_426()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_364() |
| { |
| if (jj_scan_token(GE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_363() |
| { |
| if (jj_scan_token(LE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_362() |
| { |
| if (jj_scan_token(GT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_361() |
| { |
| if (jj_scan_token(LT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_376() |
| { |
| if (jj_3R_163()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_346() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_361()) { |
| jj_scanpos = xsp; |
| if (jj_3R_362()) { |
| jj_scanpos = xsp; |
| if (jj_3R_363()) { |
| jj_scanpos = xsp; |
| if (jj_3R_364()) return true; |
| } |
| } |
| } |
| if (jj_3R_339()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_37() |
| { |
| if (jj_3R_96()) return true; |
| if (jj_scan_token(COLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_102() |
| { |
| if (jj_3R_101()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_367() |
| { |
| if (jj_3R_183()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_66() |
| { |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_102()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(IDENTIFIER)) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_376()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_377()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_401() |
| { |
| if (jj_3R_419()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_387() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_401()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_402()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_403()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_337() |
| { |
| if (jj_3R_339()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_346()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_386() |
| { |
| if (jj_3R_96()) return true; |
| if (jj_scan_token(COLON)) return true; |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_352() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_367()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_338() |
| { |
| if (jj_scan_token(BIT_AND)) return true; |
| if (jj_3R_314()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_325() |
| { |
| if (jj_scan_token(FOR)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_386()) { |
| jj_scanpos = xsp; |
| if (jj_3R_387()) return true; |
| } |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_277()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_332() |
| { |
| if (jj_3R_337()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_342()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_351() |
| { |
| if (jj_3R_66()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_3()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_344() |
| { |
| if (jj_scan_token(NE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_343() |
| { |
| if (jj_scan_token(EQ)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_340() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_343()) { |
| jj_scanpos = xsp; |
| if (jj_3R_344()) return true; |
| } |
| if (jj_3R_332()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_333() |
| { |
| if (jj_scan_token(XOR)) return true; |
| if (jj_3R_285()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_324() |
| { |
| if (jj_scan_token(DO)) return true; |
| if (jj_3R_277()) return true; |
| if (jj_scan_token(WHILE)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_80()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_350() |
| { |
| if (jj_3R_366()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_315() |
| { |
| if (jj_scan_token(BIT_OR)) return true; |
| if (jj_3R_265()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_314() |
| { |
| if (jj_3R_332()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_340()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_271() |
| { |
| if (jj_scan_token(ENUM)) return true; |
| if (jj_3R_98()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_350()) jj_scanpos = xsp; |
| if (jj_scan_token(LBRACE)) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_351()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(113)) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_352()) jj_scanpos = xsp; |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_323() |
| { |
| if (jj_scan_token(WHILE)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_80()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_277()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_286() |
| { |
| if (jj_scan_token(SC_AND)) return true; |
| if (jj_3R_237()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_285() |
| { |
| if (jj_3R_314()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_338()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_267() |
| { |
| if (jj_scan_token(SC_OR)) return true; |
| if (jj_3R_207()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_375() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_251()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_366() |
| { |
| if (jj_scan_token(IMPLEMENTS)) return true; |
| if (jj_3R_251()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_375()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_265() |
| { |
| if (jj_3R_285()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_333()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_322() |
| { |
| if (jj_scan_token(IF)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_80()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_277()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_385()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_237() |
| { |
| if (jj_3R_265()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_315()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_374() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_251()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_365() |
| { |
| if (jj_scan_token(EXTENDS)) return true; |
| if (jj_3R_251()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_374()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_207() |
| { |
| if (jj_3R_237()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_286()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_418() |
| { |
| if (jj_scan_token(_DEFAULT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_417() |
| { |
| if (jj_scan_token(CASE)) return true; |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_289() |
| { |
| if (jj_scan_token(INTERFACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_349() |
| { |
| if (jj_3R_366()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_176() |
| { |
| if (jj_3R_207()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_267()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_348() |
| { |
| if (jj_3R_365()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_400() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_417()) { |
| jj_scanpos = xsp; |
| if (jj_3R_418()) return true; |
| } |
| if (jj_scan_token(COLON)) return true; |
| if (jj_3R_160()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_347() |
| { |
| if (jj_3R_103()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_270() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(45)) { |
| jj_scanpos = xsp; |
| if (jj_3R_289()) return true; |
| } |
| if (jj_3R_98()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_347()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_348()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_349()) jj_scanpos = xsp; |
| if (jj_3R_93()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_150() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_149()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_241() |
| { |
| if (jj_scan_token(HOOK)) return true; |
| if (jj_3R_80()) return true; |
| if (jj_scan_token(COLON)) return true; |
| if (jj_3R_129()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_384() |
| { |
| if (jj_3R_400()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_129() |
| { |
| if (jj_3R_176()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_241()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_321() |
| { |
| if (jj_scan_token(SWITCH)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_80()) 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_384()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_128() |
| { |
| if (jj_scan_token(ORASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_424() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_127() |
| { |
| if (jj_scan_token(XORASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_126() |
| { |
| if (jj_scan_token(ANDASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_125() |
| { |
| if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_124() |
| { |
| if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_123() |
| { |
| if (jj_scan_token(LSHIFTASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_416() |
| { |
| if (jj_scan_token(ARROW)) return true; |
| if (jj_3R_268()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_122() |
| { |
| if (jj_scan_token(MINUSASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_121() |
| { |
| if (jj_scan_token(PLUSASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_415() |
| { |
| if (jj_scan_token(DOUBLECOLON)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_424()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(103)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(68)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_120() |
| { |
| if (jj_scan_token(REMASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_414() |
| { |
| if (jj_3R_79()) return true; |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_119() |
| { |
| if (jj_scan_token(SLASHASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_118() |
| { |
| if (jj_scan_token(STARASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_413() |
| { |
| if (jj_scan_token(DECR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_117() |
| { |
| if (jj_scan_token(ASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_412() |
| { |
| if (jj_scan_token(INCR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_399() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_412()) { |
| jj_scanpos = xsp; |
| if (jj_3R_413()) { |
| jj_scanpos = xsp; |
| if (jj_3R_414()) { |
| jj_scanpos = xsp; |
| if (jj_3R_415()) { |
| jj_scanpos = xsp; |
| if (jj_3R_416()) return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_79() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_117()) { |
| jj_scanpos = xsp; |
| if (jj_3R_118()) { |
| jj_scanpos = xsp; |
| if (jj_3R_119()) { |
| jj_scanpos = xsp; |
| if (jj_3R_120()) { |
| jj_scanpos = xsp; |
| if (jj_3R_121()) { |
| jj_scanpos = xsp; |
| if (jj_3R_122()) { |
| jj_scanpos = xsp; |
| if (jj_3R_123()) { |
| jj_scanpos = xsp; |
| if (jj_3R_124()) { |
| jj_scanpos = xsp; |
| if (jj_3R_125()) { |
| jj_scanpos = xsp; |
| if (jj_3R_126()) { |
| jj_scanpos = xsp; |
| if (jj_3R_127()) { |
| jj_scanpos = xsp; |
| if (jj_3R_128()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_336() |
| { |
| if (jj_3R_266()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_399()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_335() |
| { |
| if (jj_3R_216()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_269() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_36() |
| { |
| if (jj_3R_97()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_243() |
| { |
| if (jj_scan_token(DOUBLECOLON)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_269()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(103)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(68)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_320() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_36()) { |
| jj_scanpos = xsp; |
| if (jj_3R_335()) { |
| jj_scanpos = xsp; |
| if (jj_3R_336()) return true; |
| } |
| } |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_65() |
| { |
| if (jj_3R_101()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_64() |
| { |
| if (jj_scan_token(STRICTFP)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_63() |
| { |
| if (jj_scan_token(VOLATILE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_62() |
| { |
| if (jj_scan_token(TRANSIENT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_61() |
| { |
| if (jj_scan_token(NATIVE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_60() |
| { |
| if (jj_scan_token(SYNCHRONIZED)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_288() |
| { |
| if (jj_3R_106()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_59() |
| { |
| if (jj_scan_token(ABSTRACT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_58() |
| { |
| if (jj_scan_token(FINAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_18() |
| { |
| if (jj_3R_79()) return true; |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_242() |
| { |
| if (jj_scan_token(ARROW)) return true; |
| if (jj_3R_268()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_57() |
| { |
| if (jj_scan_token(PRIVATE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_56() |
| { |
| if (jj_scan_token(PROTECTED)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_213() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_18()) { |
| jj_scanpos = xsp; |
| if (jj_3R_242()) { |
| jj_scanpos = xsp; |
| if (jj_3R_243()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_287() |
| { |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_55() |
| { |
| if (jj_scan_token(STATIC)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_54() |
| { |
| if (jj_scan_token(PUBLIC)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_80() |
| { |
| if (jj_3R_129()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_213()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3_2() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_54()) { |
| jj_scanpos = xsp; |
| if (jj_3R_55()) { |
| jj_scanpos = xsp; |
| if (jj_3R_56()) { |
| jj_scanpos = xsp; |
| if (jj_3R_57()) { |
| jj_scanpos = xsp; |
| if (jj_3R_58()) { |
| jj_scanpos = xsp; |
| if (jj_3R_59()) { |
| jj_scanpos = xsp; |
| if (jj_3R_60()) { |
| jj_scanpos = xsp; |
| if (jj_3R_61()) { |
| 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()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_268() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_287()) { |
| jj_scanpos = xsp; |
| if (jj_3R_288()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_95() |
| { |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_2()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_319() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_35() |
| { |
| if (jj_3R_96()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_96() |
| { |
| if (jj_3R_95()) return true; |
| if (jj_3R_68()) return true; |
| if (jj_3R_149()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_150()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_202() |
| { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_34() |
| { |
| if (jj_3R_95()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(45)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(65)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_255() |
| { |
| if (jj_3R_277()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_383() |
| { |
| if (jj_scan_token(COLON)) return true; |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_17() |
| { |
| if (jj_scan_token(DOT)) return true; |
| if (jj_scan_token(IDENTIFIER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_254() |
| { |
| if (jj_3R_96()) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_98() |
| { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_17()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_53() |
| { |
| if (jj_3R_78()) return true; |
| if (jj_scan_token(PACKAGE)) return true; |
| if (jj_3R_98()) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_253() |
| { |
| if (jj_3R_95()) return true; |
| if (jj_3R_270()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_147() |
| { |
| if (jj_3R_68()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_146() |
| { |
| if (jj_scan_token(VOID)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_220() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_253()) { |
| jj_scanpos = xsp; |
| if (jj_3R_254()) { |
| jj_scanpos = xsp; |
| if (jj_3R_255()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_1() |
| { |
| if (jj_3R_53()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_91() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_146()) { |
| jj_scanpos = xsp; |
| if (jj_3R_147()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_140() |
| { |
| if (jj_scan_token(DOUBLE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_106() |
| { |
| if (jj_scan_token(LBRACE)) return true; |
| if (jj_3R_160()) return true; |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_139() |
| { |
| if (jj_scan_token(FLOAT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_138() |
| { |
| if (jj_scan_token(LONG)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_137() |
| { |
| if (jj_scan_token(INT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_136() |
| { |
| if (jj_scan_token(SHORT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_135() |
| { |
| if (jj_scan_token(BYTE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_94() |
| { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| if (jj_scan_token(COLON)) return true; |
| if (jj_3R_277()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_134() |
| { |
| if (jj_scan_token(CHAR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_133() |
| { |
| if (jj_scan_token(BOOLEAN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_313() |
| { |
| if (jj_scan_token(SUPER)) return true; |
| if (jj_3R_78()) return true; |
| if (jj_3R_75()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_87() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_133()) { |
| jj_scanpos = xsp; |
| if (jj_3R_134()) { |
| jj_scanpos = xsp; |
| if (jj_3R_135()) { |
| jj_scanpos = xsp; |
| if (jj_3R_136()) { |
| jj_scanpos = xsp; |
| 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()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_204() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_175()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_312() |
| { |
| if (jj_scan_token(EXTENDS)) return true; |
| if (jj_3R_78()) return true; |
| if (jj_3R_75()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_284() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_312()) { |
| jj_scanpos = xsp; |
| if (jj_3R_313()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_318() |
| { |
| if (jj_scan_token(ASSERT)) return true; |
| if (jj_3R_80()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_383()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_308() |
| { |
| if (jj_3R_331()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_307() |
| { |
| if (jj_3R_330()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_306() |
| { |
| if (jj_3R_329()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_305() |
| { |
| if (jj_3R_328()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_304() |
| { |
| if (jj_3R_327()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_303() |
| { |
| if (jj_3R_326()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_236() |
| { |
| if (jj_scan_token(HOOK)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_284()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_302() |
| { |
| if (jj_3R_325()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_301() |
| { |
| if (jj_3R_324()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_300() |
| { |
| if (jj_3R_323()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_299() |
| { |
| if (jj_3R_322()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_298() |
| { |
| if (jj_3R_321()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_297() |
| { |
| if (jj_3R_320()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_206() |
| { |
| if (jj_3R_236()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_296() |
| { |
| if (jj_3R_319()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_205() |
| { |
| if (jj_3R_75()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_295() |
| { |
| if (jj_3R_106()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_294() |
| { |
| if (jj_3R_318()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_175() |
| { |
| if (jj_3R_78()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_205()) { |
| jj_scanpos = xsp; |
| if (jj_3R_206()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3_33() |
| { |
| if (jj_3R_94()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_115() |
| { |
| if (jj_3R_175()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_204()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_277() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_33()) { |
| jj_scanpos = xsp; |
| if (jj_3R_294()) { |
| jj_scanpos = xsp; |
| if (jj_3R_295()) { |
| jj_scanpos = xsp; |
| if (jj_3R_296()) { |
| jj_scanpos = xsp; |
| if (jj_3R_297()) { |
| jj_scanpos = xsp; |
| if (jj_3R_298()) { |
| jj_scanpos = xsp; |
| if (jj_3R_299()) { |
| jj_scanpos = xsp; |
| if (jj_3R_300()) { |
| jj_scanpos = xsp; |
| if (jj_3R_301()) { |
| jj_scanpos = xsp; |
| if (jj_3R_302()) { |
| jj_scanpos = xsp; |
| if (jj_3R_303()) { |
| jj_scanpos = xsp; |
| if (jj_3R_304()) { |
| jj_scanpos = xsp; |
| if (jj_3R_305()) { |
| jj_scanpos = xsp; |
| if (jj_3R_306()) { |
| jj_scanpos = xsp; |
| if (jj_3R_307()) { |
| jj_scanpos = xsp; |
| if (jj_3R_308()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_77() |
| { |
| if (jj_scan_token(LT)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_115()) jj_scanpos = xsp; |
| if (jj_scan_token(GT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_16() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_32() |
| { |
| if (jj_3R_93()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_15() |
| { |
| if (jj_scan_token(DOT)) return true; |
| if (jj_3R_78()) return true; |
| if (jj_scan_token(IDENTIFIER)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_16()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_311() |
| { |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_283() |
| { |
| if (jj_3R_161()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_282() |
| { |
| if (jj_3R_78()) return true; |
| if (jj_scan_token(LBRACKET)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_311()) jj_scanpos = xsp; |
| if (jj_scan_token(RBRACKET)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_261() |
| { |
| Token xsp; |
| if (jj_3R_282()) return true; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_282()) { jj_scanpos = xsp; break; } |
| } |
| xsp = jj_scanpos; |
| if (jj_3R_283()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3_14() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_174() |
| { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_14()) jj_scanpos = xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_15()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_256() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_264() |
| { |
| if (jj_3R_163()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_32()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_263() |
| { |
| if (jj_3R_261()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_262() |
| { |
| if (jj_3R_77()) return true; |
| if (jj_3R_78()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_235() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_262()) jj_scanpos = xsp; |
| if (jj_3R_251()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_263()) { |
| jj_scanpos = xsp; |
| if (jj_3R_264()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_234() |
| { |
| if (jj_3R_87()) return true; |
| if (jj_3R_261()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_251() |
| { |
| if (jj_3R_78()) return true; |
| if (jj_3R_174()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_13() |
| { |
| if (jj_3R_76()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_428() |
| { |
| if (jj_3R_430()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_200() |
| { |
| if (jj_scan_token(NEW)) return true; |
| if (jj_3R_78()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_234()) { |
| jj_scanpos = xsp; |
| if (jj_3R_235()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3_12() |
| { |
| if (jj_3R_76()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_355() |
| { |
| if (jj_scan_token(THROWS)) return true; |
| if (jj_3R_370()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_371()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_76() |
| { |
| if (jj_3R_78()) return true; |
| if (jj_scan_token(LBRACKET)) return true; |
| if (jj_scan_token(RBRACKET)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_221() |
| { |
| if (jj_3R_80()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_256()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_195() |
| { |
| if (jj_3R_221()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_114() |
| { |
| if (jj_3R_174()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_13()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_163() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_195()) jj_scanpos = xsp; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_113() |
| { |
| if (jj_3R_87()) return true; |
| Token xsp; |
| if (jj_3_12()) return true; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_12()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_75() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_113()) { |
| jj_scanpos = xsp; |
| if (jj_3R_114()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_258() |
| { |
| if (jj_scan_token(NULL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_279() |
| { |
| if (jj_scan_token(FALSE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_278() |
| { |
| if (jj_scan_token(TRUE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_104() |
| { |
| if (jj_3R_87()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_11() |
| { |
| if (jj_3R_75()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_68() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_11()) { |
| jj_scanpos = xsp; |
| if (jj_3R_104()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_257() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_278()) { |
| jj_scanpos = xsp; |
| if (jj_3R_279()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_430() |
| { |
| if (jj_scan_token(_DEFAULT)) return true; |
| if (jj_3R_100()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_228() |
| { |
| if (jj_3R_258()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_227() |
| { |
| if (jj_3R_257()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_226() |
| { |
| if (jj_scan_token(STRING_LITERAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_105() |
| { |
| if (jj_scan_token(STATIC)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_225() |
| { |
| if (jj_scan_token(CHARACTER_LITERAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_423() |
| { |
| if (jj_3R_68()) return true; |
| if (jj_scan_token(IDENTIFIER)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_428()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_70() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_105()) jj_scanpos = xsp; |
| if (jj_3R_106()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_224() |
| { |
| if (jj_scan_token(FLOATING_POINT_LITERAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_194() |
| { |
| if (jj_3R_220()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_44() |
| { |
| if (jj_3R_68()) return true; |
| if (jj_scan_token(IDENTIFIER)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_411() |
| { |
| if (jj_3R_274()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_160() |
| { |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_194()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_410() |
| { |
| if (jj_3R_272()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_223() |
| { |
| if (jj_scan_token(LONG_LITERAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_9() |
| { |
| if (jj_3R_73()) return true; |
| if (jj_scan_token(DOT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_409() |
| { |
| if (jj_3R_271()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_408() |
| { |
| if (jj_3R_270()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_222() |
| { |
| if (jj_scan_token(INTEGER_LITERAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_407() |
| { |
| if (jj_3R_423()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_74() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_165() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_10() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_74()) jj_scanpos = xsp; |
| if (jj_scan_token(THIS)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_164() |
| { |
| if (jj_3R_73()) return true; |
| if (jj_scan_token(DOT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_43() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_100()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_92() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_196() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_222()) { |
| jj_scanpos = xsp; |
| if (jj_3R_223()) { |
| jj_scanpos = xsp; |
| if (jj_3R_224()) { |
| jj_scanpos = xsp; |
| if (jj_3R_225()) { |
| jj_scanpos = xsp; |
| if (jj_3R_226()) { |
| jj_scanpos = xsp; |
| if (jj_3R_227()) { |
| jj_scanpos = xsp; |
| if (jj_3R_228()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_394() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_110() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_164()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_165()) jj_scanpos = xsp; |
| if (jj_scan_token(SUPER)) return true; |
| if (jj_3R_163()) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_143() |
| { |
| if (jj_scan_token(LBRACKET)) return true; |
| if (jj_3R_80()) return true; |
| if (jj_scan_token(RBRACKET)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_31() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_92()) jj_scanpos = xsp; |
| if (jj_scan_token(IDENTIFIER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_395() |
| { |
| if (jj_3R_95()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_407()) { |
| jj_scanpos = xsp; |
| if (jj_3R_408()) { |
| jj_scanpos = xsp; |
| if (jj_3R_409()) { |
| jj_scanpos = xsp; |
| if (jj_3R_410()) { |
| jj_scanpos = xsp; |
| if (jj_3R_411()) return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_162() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_109() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_162()) jj_scanpos = xsp; |
| if (jj_scan_token(THIS)) return true; |
| if (jj_3R_163()) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_212() |
| { |
| if (jj_3R_163()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_378() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_394()) { |
| jj_scanpos = xsp; |
| if (jj_3R_395()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_211() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_181() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_211()) jj_scanpos = xsp; |
| if (jj_3R_202()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_212()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_368() |
| { |
| if (jj_3R_378()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_180() |
| { |
| if (jj_3R_200()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_72() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_109()) { |
| jj_scanpos = xsp; |
| if (jj_3R_110()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_179() |
| { |
| if (jj_scan_token(THIS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_353() |
| { |
| if (jj_scan_token(LBRACE)) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_368()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_259() |
| { |
| if (jj_3R_280()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_8() |
| { |
| if (jj_3R_72()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_144() |
| { |
| if (jj_scan_token(ELLIPSIS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_142() |
| { |
| if (jj_scan_token(DOT)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_179()) { |
| jj_scanpos = xsp; |
| if (jj_3R_180()) { |
| jj_scanpos = xsp; |
| if (jj_3R_181()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_309() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_89() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_142()) { |
| jj_scanpos = xsp; |
| if (jj_3R_143()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_356() |
| { |
| if (jj_3R_72()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_272() |
| { |
| if (jj_scan_token(AT)) return true; |
| if (jj_scan_token(INTERFACE)) return true; |
| if (jj_3R_98()) return true; |
| if (jj_3R_353()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_371() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_370()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_317() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_316()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_290() |
| { |
| if (jj_3R_103()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_141() |
| { |
| if (jj_scan_token(DOT)) return true; |
| if (jj_scan_token(SUPER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_273() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_290()) jj_scanpos = xsp; |
| if (jj_3R_202()) return true; |
| if (jj_3R_354()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_355()) jj_scanpos = xsp; |
| if (jj_scan_token(LBRACE)) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_356()) jj_scanpos = xsp; |
| if (jj_3R_160()) return true; |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_334() |
| { |
| if (jj_3R_100()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_43()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_30() |
| { |
| if (jj_3R_89()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_201() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_379() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_88() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_30()) { |
| jj_scanpos = xsp; |
| if (jj_3R_141()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_189() |
| { |
| if (jj_scan_token(LBRACE)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_334()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(113)) jj_scanpos = xsp; |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_203() |
| { |
| if (jj_3R_163()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_154() |
| { |
| if (jj_3R_129()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_153() |
| { |
| if (jj_3R_189()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_173() |
| { |
| if (jj_3R_202()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_203()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_152() |
| { |
| if (jj_3R_101()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_29() |
| { |
| if (jj_3R_91()) return true; |
| if (jj_scan_token(DOUBLECOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_28() |
| { |
| if (jj_3R_91()) return true; |
| if (jj_scan_token(DOT)) return true; |
| if (jj_scan_token(CLASS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_90() |
| { |
| if (jj_3R_95()) return true; |
| if (jj_3R_68()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_144()) jj_scanpos = xsp; |
| if (jj_3R_145()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_100() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_152()) { |
| jj_scanpos = xsp; |
| if (jj_3R_153()) { |
| jj_scanpos = xsp; |
| if (jj_3R_154()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_7() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_71()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_260() |
| { |
| if (jj_3R_281()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_172() |
| { |
| if (jj_3R_91()) return true; |
| if (jj_scan_token(DOUBLECOLON)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_201()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(103)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(68)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_276() |
| { |
| if (jj_3R_293()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_171() |
| { |
| if (jj_3R_91()) return true; |
| if (jj_scan_token(DOT)) return true; |
| if (jj_scan_token(CLASS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_316() |
| { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| if (jj_scan_token(ASSIGN)) return true; |
| if (jj_3R_100()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_310() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_145()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_170() |
| { |
| if (jj_3R_200()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_281() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_145()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_310()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_27() |
| { |
| if (jj_3R_90()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_293() |
| { |
| if (jj_3R_316()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_317()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_358() |
| { |
| if (jj_3R_76()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_233() |
| { |
| if (jj_3R_80()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_260()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_280() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_90()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_309()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_232() |
| { |
| if (jj_3R_90()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_259()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_199() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_232()) { |
| jj_scanpos = xsp; |
| if (jj_3R_233()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_231() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_369() |
| { |
| if (jj_3R_90()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_379()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_191() |
| { |
| if (jj_scan_token(AT)) return true; |
| if (jj_3R_98()) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_100()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_99() |
| { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| if (jj_scan_token(ASSIGN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_169() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_199()) jj_scanpos = xsp; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_198() |
| { |
| if (jj_scan_token(DOUBLECOLON)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_231()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(103)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(68)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_354() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_369()) jj_scanpos = xsp; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_192() |
| { |
| if (jj_scan_token(AT)) return true; |
| if (jj_3R_98()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_42() |
| { |
| if (jj_scan_token(AT)) return true; |
| if (jj_3R_98()) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_41() |
| { |
| if (jj_scan_token(AT)) return true; |
| if (jj_3R_98()) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_99()) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(107)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_230() |
| { |
| if (jj_3R_163()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_190() |
| { |
| if (jj_scan_token(AT)) return true; |
| if (jj_3R_98()) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_276()) jj_scanpos = xsp; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_370() |
| { |
| if (jj_3R_78()) return true; |
| if (jj_3R_75()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_197() |
| { |
| if (jj_scan_token(DOT)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_229()) jj_scanpos = xsp; |
| if (jj_3R_202()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_230()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_229() |
| { |
| if (jj_3R_77()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_40() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| if (jj_3R_96()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_26() |
| { |
| if (jj_3R_89()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_157() |
| { |
| if (jj_3R_192()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_182() |
| { |
| if (jj_3R_76()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_168() |
| { |
| if (jj_scan_token(SUPER)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_197()) { |
| jj_scanpos = xsp; |
| if (jj_3R_198()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_156() |
| { |
| if (jj_3R_191()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_167() |
| { |
| if (jj_scan_token(THIS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_155() |
| { |
| if (jj_3R_190()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_166() |
| { |
| if (jj_3R_196()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_292() |
| { |
| if (jj_3R_71()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_7()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_372() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_370()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_360() |
| { |
| if (jj_3R_106()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_112() |
| { |
| if (jj_3R_89()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_359() |
| { |
| if (jj_scan_token(THROWS)) return true; |
| if (jj_3R_370()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_372()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_291() |
| { |
| if (jj_3R_103()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_111() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_166()) { |
| jj_scanpos = xsp; |
| if (jj_3R_167()) { |
| jj_scanpos = xsp; |
| if (jj_3R_168()) { |
| jj_scanpos = xsp; |
| if (jj_3R_169()) { |
| jj_scanpos = xsp; |
| if (jj_3R_170()) { |
| jj_scanpos = xsp; |
| if (jj_3R_171()) { |
| jj_scanpos = xsp; |
| if (jj_3R_172()) { |
| jj_scanpos = xsp; |
| if (jj_3R_173()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_101() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_155()) { |
| jj_scanpos = xsp; |
| if (jj_3R_156()) { |
| jj_scanpos = xsp; |
| if (jj_3R_157()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_275() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_291()) jj_scanpos = xsp; |
| if (jj_3R_91()) return true; |
| if (jj_3R_98()) return true; |
| if (jj_3R_354()) return true; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_358()) { jj_scanpos = xsp; break; } |
| } |
| xsp = jj_scanpos; |
| if (jj_3R_359()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_360()) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(112)) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3_25() |
| { |
| if (jj_3R_88()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_116() |
| { |
| if (jj_3R_101()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_78() |
| { |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_116()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_130() |
| { |
| return false; |
| } |
| |
| private boolean jj_3R_73() |
| { |
| if (jj_3R_111()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_112()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_131() |
| { |
| return false; |
| } |
| |
| private boolean jj_3R_161() |
| { |
| if (jj_scan_token(LBRACE)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_292()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(113)) jj_scanpos = xsp; |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_82() |
| { |
| jj_lookingAhead = true; |
| jj_semLA = getToken(1).kind == GT && |
| ((GTToken)getToken(1)).realKind == RSIGNEDSHIFT; |
| jj_lookingAhead = false; |
| if (!jj_semLA || jj_3R_130()) return true; |
| if (jj_scan_token(GT)) return true; |
| if (jj_scan_token(GT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_108() |
| { |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_107() |
| { |
| if (jj_3R_161()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_184() |
| { |
| if (jj_scan_token(ASSIGN)) return true; |
| if (jj_3R_71()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_266() |
| { |
| if (jj_3R_111()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_25()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_83() |
| { |
| jj_lookingAhead = true; |
| jj_semLA = getToken(1).kind == GT && |
| ((GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT; |
| jj_lookingAhead = false; |
| if (!jj_semLA || jj_3R_131()) 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_71() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_107()) { |
| jj_scanpos = xsp; |
| if (jj_3R_108()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_177() |
| { |
| if (jj_scan_token(BIT_AND)) return true; |
| if (jj_3R_75()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_132() |
| { |
| if (jj_3R_75()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_177()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_178()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_421() |
| { |
| if (jj_3R_96()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_40()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_145() |
| { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_182()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_24() |
| { |
| if (jj_3R_87()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_151()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_84() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_78()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_24()) { |
| jj_scanpos = xsp; |
| if (jj_3R_132()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3_39() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_149() |
| { |
| if (jj_3R_145()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_184()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_404() |
| { |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_421()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_39()) jj_scanpos = xsp; |
| if (jj_scan_token(RPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_406() |
| { |
| if (jj_scan_token(FINALLY)) return true; |
| if (jj_3R_106()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_393() |
| { |
| if (jj_scan_token(FINALLY)) return true; |
| if (jj_3R_106()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_422() |
| { |
| if (jj_scan_token(BIT_OR)) return true; |
| if (jj_3R_370()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_69() |
| { |
| if (jj_3R_76()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_86() |
| { |
| if (jj_scan_token(DECR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_23() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_85()) { |
| jj_scanpos = xsp; |
| if (jj_3R_86()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_85() |
| { |
| if (jj_scan_token(INCR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_357() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_149()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_22() |
| { |
| if (jj_3R_84()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_405() |
| { |
| if (jj_scan_token(CATCH)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_95()) return true; |
| if (jj_3R_75()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_422()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_3R_145()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_106()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_274() |
| { |
| if (jj_3R_68()) return true; |
| if (jj_3R_149()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_357()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_240() |
| { |
| if (jj_3R_266()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_23()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_215() |
| { |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_209() |
| { |
| if (jj_3R_84()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_210() |
| { |
| if (jj_3R_240()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_239() |
| { |
| if (jj_scan_token(BANG)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_238() |
| { |
| if (jj_scan_token(TILDE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_208() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_238()) { |
| jj_scanpos = xsp; |
| if (jj_3R_239()) return true; |
| } |
| if (jj_3R_151()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_5() |
| { |
| if (jj_3R_68()) return true; |
| if (jj_scan_token(IDENTIFIER)) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_69()) { jj_scanpos = xsp; break; } |
| } |
| xsp = jj_scanpos; |
| if (jj_scan_token(113)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(116)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(112)) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_392() |
| { |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_405()) { jj_scanpos = xsp; break; } |
| } |
| xsp = jj_scanpos; |
| if (jj_3R_406()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_67() |
| { |
| if (jj_3R_103()) return true; |
| return false; |
| } |
| |
| private boolean jj_3_4() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_67()) jj_scanpos = xsp; |
| if (jj_scan_token(IDENTIFIER)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_178() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| 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_250() |
| { |
| if (jj_3R_275()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_391() |
| { |
| if (jj_3R_404()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_331() |
| { |
| if (jj_scan_token(TRY)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_391()) jj_scanpos = xsp; |
| if (jj_3R_106()) return true; |
| xsp = jj_scanpos; |
| if (jj_3R_392()) { |
| jj_scanpos = xsp; |
| if (jj_3R_393()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_244() |
| { |
| if (jj_scan_token(_DEFAULT)) return true; |
| if (jj_3R_95()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_249() |
| { |
| if (jj_3R_274()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_248() |
| { |
| if (jj_3R_273()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_247() |
| { |
| if (jj_3R_272()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_216() |
| { |
| if (jj_scan_token(DECR)) return true; |
| if (jj_3R_151()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_246() |
| { |
| if (jj_3R_271()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_245() |
| { |
| if (jj_3R_270()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_390() |
| { |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_193() |
| { |
| if (jj_3R_219()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_97() |
| { |
| if (jj_scan_token(INCR)) return true; |
| if (jj_3R_151()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_188() |
| { |
| if (jj_3R_178()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_389() |
| { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_330() |
| { |
| if (jj_scan_token(SYNCHRONIZED)) return true; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_3R_80()) return true; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_3R_106()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_214() |
| { |
| if (jj_3R_95()) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_244()) jj_scanpos = xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_245()) { |
| jj_scanpos = xsp; |
| if (jj_3R_246()) { |
| jj_scanpos = xsp; |
| if (jj_3R_247()) { |
| jj_scanpos = xsp; |
| if (jj_3R_248()) { |
| jj_scanpos = xsp; |
| if (jj_3R_249()) { |
| jj_scanpos = xsp; |
| if (jj_3R_250()) return true; |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3_6() |
| { |
| if (jj_3R_70()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_388() |
| { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_218() |
| { |
| if (jj_scan_token(MINUS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_217() |
| { |
| if (jj_scan_token(PLUS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_329() |
| { |
| if (jj_scan_token(THROW)) return true; |
| if (jj_3R_80()) return true; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_187() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_217()) { |
| jj_scanpos = xsp; |
| if (jj_3R_218()) return true; |
| } |
| if (jj_3R_151()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_186() |
| { |
| if (jj_3R_216()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_185() |
| { |
| if (jj_3R_97()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_183() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_6()) { |
| jj_scanpos = xsp; |
| if (jj_3R_214()) { |
| jj_scanpos = xsp; |
| if (jj_3R_215()) return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_429() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_80()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_328() |
| { |
| if (jj_scan_token(RETURN)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_390()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_148() |
| { |
| if (jj_3R_183()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_151() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_185()) { |
| jj_scanpos = xsp; |
| if (jj_3R_186()) { |
| jj_scanpos = xsp; |
| if (jj_3R_187()) { |
| jj_scanpos = xsp; |
| if (jj_3R_188()) return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_398() |
| { |
| if (jj_scan_token(REM)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_397() |
| { |
| if (jj_scan_token(SLASH)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_327() |
| { |
| if (jj_scan_token(CONTINUE)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_389()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_93() |
| { |
| if (jj_scan_token(LBRACE)) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_148()) { jj_scanpos = xsp; break; } |
| } |
| if (jj_scan_token(RBRACE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_396() |
| { |
| if (jj_scan_token(STAR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_380() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_396()) { |
| jj_scanpos = xsp; |
| if (jj_3R_397()) { |
| jj_scanpos = xsp; |
| if (jj_3R_398()) return true; |
| } |
| } |
| if (jj_3R_151()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_403() |
| { |
| if (jj_3R_420()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_252() |
| { |
| if (jj_scan_token(BIT_AND)) return true; |
| if (jj_3R_251()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_326() |
| { |
| if (jj_scan_token(BREAK)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_388()) jj_scanpos = xsp; |
| if (jj_scan_token(SEMICOLON)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_219() |
| { |
| if (jj_scan_token(EXTENDS)) return true; |
| if (jj_3R_251()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_252()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_345() |
| { |
| if (jj_3R_151()) return true; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_380()) { jj_scanpos = xsp; break; } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_382() |
| { |
| if (jj_scan_token(MINUS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_381() |
| { |
| if (jj_scan_token(PLUS)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_3() |
| { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_3R_66()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_373() |
| { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_381()) { |
| jj_scanpos = xsp; |
| if (jj_3R_382()) return true; |
| } |
| if (jj_3R_345()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_158() |
| { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_193()) jj_scanpos = xsp; |
| return false; |
| } |
| |
| private boolean jj_3R_420() |
| { |
| if (jj_3R_427()) return true; |
| return false; |
| } |
| |
| /** Generated Token Manager. */ |
| public ASTParserTokenManager token_source; |
| JavaCharStream 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[160]; |
| 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[] {0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,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,}; |
| } |
| private static void jj_la1_init_1() { |
| jj_la1_1 = new int[] {0x40000000,0x40000000,0x902020,0x0,0x0,0x0,0x800020,0x102000,0x902020,0x2000,0x0,0x200000,0x20000000,0x0,0x0,0x20000000,0x0,0x0,0x29532a0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x29532a0,0x10000,0x102000,0x2041280,0x29532a0,0x0,0x0,0x0,0x2441280,0x2441280,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28412a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2441280,0x16c6b3e0,0x0,0x2041280,0x2041280,0x2041280,0x0,0x2041280,0x2041280,0x200000,0x200000,0x2041280,0x2041280,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2441280,0x0,0x0,0x2441280,0x0,0x0,0x2041280,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2441280,0x2c412a0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x2441280,0x0,0x0,0x0,0x2041280,0x2441280,0x0,0x0,0x164693c0,0x0,0x164693c0,0x0,0x2441280,0x0,0x0,0x0,0x0,0x2441280,0x10400,0x10400,0x80000,0x2c412a0,0x2441280,0x2441280,0x2c412a0,0x2441280,0x0,0x0,0x0,0x2441280,0x0,0x800,0x0,0x1000000,0x0,0x0,0x0,0x0,0x2441280,0x2441280,0x0,0x29432a0,0x2143280,0x29432a0,0x10000,}; |
| } |
| private static void jj_la1_init_2() { |
| jj_la1_2 = new int[] {0x0,0x0,0x111338a,0x0,0x1000,0x0,0x1113388,0x2,0x111338a,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1913b8f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1913b8f,0x0,0x2,0x800805,0x1913b8f,0x0,0x0,0x0,0xca24835,0xca24835,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x1113b8d,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0xca24835,0xff7ffbf,0x1000,0x805,0x805,0x805,0x0,0x805,0x805,0x4000,0x4000,0x805,0x800805,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xca24835,0x0,0x0,0xca24835,0x0,0x0,0x805,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0xca24835,0xdb37bbd,0x0,0x10,0x0,0xc224030,0x0,0x0,0x0,0x0,0x20010,0x0,0xc200020,0x200000,0xca24835,0x0,0x0,0x0,0x805,0xca24835,0x0,0x0,0xee7cc35,0x0,0xee7cc35,0x0,0xca24835,0x0,0x10,0x0,0x0,0xca24835,0x0,0x0,0x0,0xdb37bbd,0xca24835,0xca24835,0xdb37bbd,0xca24835,0x0,0x0,0x0,0xca24835,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xca24835,0xca24835,0x0,0x1113b8f,0x807,0x1113b8f,0x0,}; |
| } |
| private static void jj_la1_init_3() { |
| jj_la1_3 = new int[] {0x10000,0x10000,0x90000,0x0,0x0,0x40000,0x80000,0x80000,0x90000,0x0,0x200000,0x0,0x0,0x20000,0x20000,0x0,0x80080,0x20000,0x291080,0x10000,0x80000,0x400,0x1000,0x20000,0x0,0x0,0x291080,0x0,0x80000,0x200080,0x290080,0x20000,0x100000,0x84000,0xc014e1,0xc014e1,0x20000,0x200000,0x84000,0x20000,0x0,0x11000,0x20000,0x80080,0x20000,0x20000,0x0,0x200000,0x20000,0x0,0x200000,0x200000,0x2004e1,0x914e1,0x0,0x0,0x80,0x80,0x20000,0x1080080,0x1000080,0x0,0x0,0x0,0x80,0x200000,0x80,0x0,0x100000,0x100000,0x1000000,0x40000000,0x80000000,0x0,0x0,0x0,0x24000000,0x24000000,0x0,0x18200000,0x18200000,0x0,0x0,0x0,0x0,0x0,0x0,0xc004e1,0xc00000,0xc00000,0x4e1,0x0,0x0,0x80,0x200000,0x400,0x200000,0x80,0x40000,0x20000,0x20000,0xc004e1,0xc804e1,0x200000,0x80,0x400,0x461,0x80,0x40000,0x200000,0x400,0x0,0x44000,0x61,0x0,0xc004e1,0x20000,0x200000,0x84400,0x280080,0xc004e1,0x84000,0x1000,0x114e1,0x2000000,0x114e1,0x20000,0xc014e1,0x200000,0x80,0x100000,0x100000,0x4e1,0x0,0x0,0x0,0xc804e1,0xc004e1,0xc004e1,0xc904e1,0xc004e1,0x20000,0x80,0x80,0xc004e1,0x400,0x0,0x0,0x0,0x80000,0x80000,0x80,0x20000,0xc814e1,0xc814e1,0x20000,0x90080,0x80080,0x90080,0x0,}; |
| } |
| private static void jj_la1_init_4() { |
| jj_la1_4 = new int[] {0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1800000,0x1bff800,0x3ff800,0x0,0x0,0x0,0x80,0x100,0x40,0x0,0x0,0x0,0x8000000,0x8000000,0x400,0xc,0xc,0x230,0x230,0xc,0xf,0x0,0x0,0x0,0x3,0x40,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0xf,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0x0,0x0,0x0,0x0,0xf,0x0,0x0,0x3,0x0,0x3,0x0,0xf,0x0,0x0,0x1bff803,0x1bff803,0x2,0x0,0x0,0x0,0xf,0xf,0xf,0xf,0xf,0x0,0x0,0x0,0xf,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0xf,0xf,0x0,0x0,0x0,0x0,0x0,}; |
| } |
| final private JJCalls[] jj_2_rtns = new JJCalls[44]; |
| private boolean jj_rescan = false; |
| private int jj_gc = 0; |
| |
| /** Constructor. */ |
| public ASTParser(Provider stream) { |
| jj_input_stream = new JavaCharStream(stream, 1, 1); |
| token_source = new ASTParserTokenManager(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 160; i++) jj_la1[i] = -1; |
| for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); |
| } |
| |
| /** Constructor. */ |
| public ASTParser(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 JavaCharStream(stream, 1, 1); |
| } else { |
| jj_input_stream.ReInit(stream, 1, 1); |
| } |
| if (token_source == null) { |
| token_source = new ASTParserTokenManager(jj_input_stream); |
| } |
| |
| token_source.ReInit(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 160; 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 ASTParser(ASTParserTokenManager tm) { |
| token_source = tm; |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 160; 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(ASTParserTokenManager tm) { |
| token_source = tm; |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 160; 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) { |
| 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[157]; |
| if (jj_kind >= 0) { |
| la1tokens[jj_kind] = true; |
| jj_kind = -1; |
| } |
| for (int i = 0; i < 160; 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 < 157; 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 : ASTParserTokenManager.lexStateNames[token_source.curLexState]); |
| } |
| |
| /** 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 < 44; 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; |
| } |
| } |
| 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; |
| } |
| |
| } |