From fe0ef2213f79f2ef12a4d645385f15721d2c3cd6 Mon Sep 17 00:00:00 2001 From: Eugene Susla Date: Thu, 26 Apr 2018 10:44:19 -0700 Subject: Javaparser Android.bp Test: mmma external/javaparser and inspect resulting out/host/linux-x86/framework/javaparser.jar (cherry picked from commit 2a66cdba31a132a02d16db7b065b243658250e36) Bug: 135178920 Merged-In: Ibf69fcb1467c0414221913f2f1a9e1599b604aa0 Change-Id: Ie76c306a05e481d571276c43a5501037ead84f14 --- Android.bp | 26 + .../com/github/javaparser/JavaParserBuild.java | 19 + .../com/github/javaparser/GeneratedJavaParser.java | 10387 +++++++++++++++++++ .../javaparser/GeneratedJavaParserConstants.java | 472 + .../GeneratedJavaParserTokenManager.java | 2966 ++++++ .../com/github/javaparser/ParseException.java | 235 + .../javacc/com/github/javaparser/Provider.java | 47 + .../com/github/javaparser/SimpleCharStream.java | 419 + .../com/github/javaparser/StreamProvider.java | 78 + .../com/github/javaparser/StringProvider.java | 68 + .../javacc/com/github/javaparser/Token.java | 152 + .../com/github/javaparser/TokenMgrException.java | 167 + 12 files changed, 15036 insertions(+) create mode 100644 Android.bp create mode 100644 javaparser-core/generated-sources/java-templates/com/github/javaparser/JavaParserBuild.java create mode 100644 javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParser.java create mode 100644 javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserConstants.java create mode 100644 javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserTokenManager.java create mode 100644 javaparser-core/generated-sources/javacc/com/github/javaparser/ParseException.java create mode 100644 javaparser-core/generated-sources/javacc/com/github/javaparser/Provider.java create mode 100644 javaparser-core/generated-sources/javacc/com/github/javaparser/SimpleCharStream.java create mode 100644 javaparser-core/generated-sources/javacc/com/github/javaparser/StreamProvider.java create mode 100644 javaparser-core/generated-sources/javacc/com/github/javaparser/StringProvider.java create mode 100644 javaparser-core/generated-sources/javacc/com/github/javaparser/Token.java create mode 100644 javaparser-core/generated-sources/javacc/com/github/javaparser/TokenMgrException.java diff --git a/Android.bp b/Android.bp new file mode 100644 index 000000000..68567d967 --- /dev/null +++ b/Android.bp @@ -0,0 +1,26 @@ +// Copyright (C) 2018 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// build javaparser jar +// ============================================================ + +java_library_host { + name: "javaparser", + + srcs: [ + "javaparser-core/src/main/java/**/*.java", + "javaparser-core/src/main/javacc-support/**/*.java", + "javaparser-core/generated-sources/**/*.java", + ], +} diff --git a/javaparser-core/generated-sources/java-templates/com/github/javaparser/JavaParserBuild.java b/javaparser-core/generated-sources/java-templates/com/github/javaparser/JavaParserBuild.java new file mode 100644 index 000000000..1fb494ece --- /dev/null +++ b/javaparser-core/generated-sources/java-templates/com/github/javaparser/JavaParserBuild.java @@ -0,0 +1,19 @@ +package com.github.javaparser; + +/** + * Some information that was available when this library was built by Maven. + */ +public class JavaParserBuild { + public static final String PROJECT_VERSION = "3.5.16-SNAPSHOT"; + public static final String PROJECT_NAME = "javaparser-core"; + public static final String PROJECT_BUILD_FINAL_NAME = "javaparser-core-3.5.16-SNAPSHOT"; + public static final String MAVEN_VERSION = "3.3.9"; + public static final String MAVEN_BUILD_VERSION = "Apache Maven 3.3.9"; + public static final String MAVEN_BUILD_TIMESTAMP = "2018-04-25T22:45:26Z"; + public static final String JAVA_VENDOR ="Oracle Corporation"; + public static final String JAVA_VENDOR_URL ="http://java.oracle.com/"; + public static final String JAVA_VERSION ="9"; + public static final String OS_ARCH ="amd64"; + public static final String OS_NAME ="Linux"; + public static final String OS_VERSION ="4.9.0-6-amd64"; +} \ No newline at end of file diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParser.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParser.java new file mode 100644 index 000000000..88d806892 --- /dev/null +++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParser.java @@ -0,0 +1,10387 @@ +/* GeneratedJavaParser.java */ +/* Generated By:JavaCC: Do not edit this line. GeneratedJavaParser.java */ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser; +import java.io.*; +import java.util.*; +import com.github.javaparser.ast.*; +import com.github.javaparser.ast.body.*; +import com.github.javaparser.ast.comments.*; +import com.github.javaparser.ast.modules.*; +import com.github.javaparser.ast.expr.*; +import com.github.javaparser.ast.stmt.*; +import com.github.javaparser.ast.type.*; +import com.github.javaparser.utils.*; +import javax.annotation.Generated; +import static com.github.javaparser.JavaToken.INVALID; +import static com.github.javaparser.ast.Node.Parsedness.UNPARSABLE; +import static com.github.javaparser.utils.Utils.*; +import static com.github.javaparser.ast.NodeList.*; +import static com.github.javaparser.GeneratedJavaParser.*; +import static com.github.javaparser.Range.*; +import static com.github.javaparser.Position.*; +import static com.github.javaparser.ast.type.ArrayType.*; +import static com.github.javaparser.GeneratedJavaParserTokenManagerBase.*; + +@Generated("JavaCC") +final class GeneratedJavaParser extends GeneratedJavaParserBase implements GeneratedJavaParserConstants { + /* Returns the JavaParser specific token type of the last matched token */ + JavaToken token() { + return token.javaToken; + } + + /* Changes the amount by which the horizontal position is increased when a tab character is encountered. + One by default.*/ + void setTabSize(int size) { + jj_input_stream.setTabSize(size); + } + + @Override + GeneratedJavaParserTokenManager getTokenSource() { + return token_source; + } + +/***************************************** + * THE JAVA LANGUAGE GRAMMAR STARTS HERE * + *****************************************/ + +/* + * Program structuring syntax follows. + */ + final public +CompilationUnit CompilationUnit() throws ParseException {PackageDeclaration pakage = null; + NodeList imports = emptyList(); + ImportDeclaration in = null; + NodeList> types = emptyList(); + ModifierHolder modifier; + TypeDeclaration tn = null; + ModuleDeclaration module = null; + try { + label_1: + while (true) { + if (jj_2_1(2)) { + ; + } else { + break label_1; + } + jj_consume_token(SEMICOLON); + } + if (jj_2_2(2147483647)) { + pakage = PackageDeclaration(); + } else { + ; + } + label_2: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case CLASS: + case _DEFAULT: + case ENUM: + case FINAL: + case IMPORT: + case INTERFACE: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOLATILE: + case OPEN: + case MODULE: + case TRANSITIVE: + case SEMICOLON: + case AT:{ + ; + break; + } + default: + jj_la1[0] = jj_gen; + break label_2; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case IMPORT:{ + in = ImportDeclaration(); +imports = add(imports, in); + break; + } + case ABSTRACT: + case CLASS: + case _DEFAULT: + case ENUM: + case FINAL: + case INTERFACE: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOLATILE: + case OPEN: + case MODULE: + case TRANSITIVE: + case SEMICOLON: + case AT:{ + modifier = Modifiers(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case CLASS: + case INTERFACE:{ + tn = ClassOrInterfaceDeclaration(modifier); +types = add(types, tn); + break; + } + case ENUM:{ + tn = EnumDeclaration(modifier); +types = add(types, tn); + break; + } + case AT:{ + tn = AnnotationTypeDeclaration(modifier); +types = add(types, tn); + break; + } + case OPEN: + case MODULE:{ + module = ModuleDeclaration(modifier); + break; + } + case SEMICOLON:{ + jj_consume_token(SEMICOLON); + break; + } + default: + jj_la1[1] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + break; + } + default: + jj_la1[2] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case 0:{ + jj_consume_token(0); + break; + } + case CTRL_Z:{ + jj_consume_token(CTRL_Z); + break; + } + default: + jj_la1[3] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return new CompilationUnit(range(token_source.getHomeToken(), token()), pakage, imports, types, module); + } catch (ParseException e) { +recover(EOF, e); + final CompilationUnit compilationUnit = new CompilationUnit(range(token_source.getHomeToken(), token()), null, new NodeList(), new NodeList>(), null); + compilationUnit.setParsed(UNPARSABLE); + return compilationUnit; + } +} + + final public PackageDeclaration PackageDeclaration() throws ParseException {NodeList annotations = new NodeList(); + Name name; + JavaToken begin; + annotations = Annotations(); + jj_consume_token(PACKAGE); +begin = token(); + name = Name(); + jj_consume_token(SEMICOLON); +return new PackageDeclaration(range(begin, token()), annotations, name); +} + + final public ImportDeclaration ImportDeclaration() throws ParseException {Name name; + boolean isStatic = false; + boolean isAsterisk = false; + JavaToken begin; + jj_consume_token(IMPORT); +begin = token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case STATIC:{ + jj_consume_token(STATIC); +isStatic = true; + break; + } + default: + jj_la1[4] = jj_gen; + ; + } + name = Name(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case DOT:{ + jj_consume_token(DOT); + jj_consume_token(STAR); +isAsterisk = true; + break; + } + default: + jj_la1[5] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); +return new ImportDeclaration(range(begin, token()), name, isStatic, isAsterisk); +} + +/* + * Modifiers. We match all modifiers in a single rule to reduce the chances of + * syntax errors for simple modifier mistakes. It will also enable us to give + * better error messages. + */ + final public +ModifierHolder Modifiers() throws ParseException {JavaToken begin = INVALID; + EnumSet modifiers = EnumSet.noneOf(Modifier.class); + NodeList annotations = new NodeList(); + AnnotationExpr ann; + label_3: + while (true) { + if (jj_2_3(2)) { + ; + } else { + break label_3; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case PUBLIC:{ + jj_consume_token(PUBLIC); +addModifier(modifiers, Modifier.PUBLIC); begin = orIfInvalid(begin, token()); + break; + } + case STATIC:{ + jj_consume_token(STATIC); +addModifier(modifiers, Modifier.STATIC); begin = orIfInvalid(begin, token()); + break; + } + case PROTECTED:{ + jj_consume_token(PROTECTED); +addModifier(modifiers, Modifier.PROTECTED); begin = orIfInvalid(begin, token()); + break; + } + case PRIVATE:{ + jj_consume_token(PRIVATE); +addModifier(modifiers, Modifier.PRIVATE); begin = orIfInvalid(begin, token()); + break; + } + case FINAL:{ + jj_consume_token(FINAL); +addModifier(modifiers, Modifier.FINAL); begin = orIfInvalid(begin, token()); + break; + } + case ABSTRACT:{ + jj_consume_token(ABSTRACT); +addModifier(modifiers, Modifier.ABSTRACT); begin = orIfInvalid(begin, token()); + break; + } + case SYNCHRONIZED:{ + jj_consume_token(SYNCHRONIZED); +addModifier(modifiers, Modifier.SYNCHRONIZED); begin = orIfInvalid(begin, token()); + break; + } + case NATIVE:{ + jj_consume_token(NATIVE); +addModifier(modifiers, Modifier.NATIVE); begin = orIfInvalid(begin, token()); + break; + } + case TRANSIENT:{ + jj_consume_token(TRANSIENT); +addModifier(modifiers, Modifier.TRANSIENT); begin = orIfInvalid(begin, token()); + break; + } + case VOLATILE:{ + jj_consume_token(VOLATILE); +addModifier(modifiers, Modifier.VOLATILE); begin = orIfInvalid(begin, token()); + break; + } + case STRICTFP:{ + jj_consume_token(STRICTFP); +addModifier(modifiers, Modifier.STRICTFP); begin = orIfInvalid(begin, token()); + break; + } + case TRANSITIVE:{ + jj_consume_token(TRANSITIVE); +addModifier(modifiers, Modifier.TRANSITIVE); begin = orIfInvalid(begin, token()); + break; + } + case _DEFAULT:{ + jj_consume_token(_DEFAULT); +addModifier(modifiers, Modifier.DEFAULT); begin = orIfInvalid(begin, token()); + break; + } + case AT:{ + ann = Annotation(); +annotations = add(annotations, ann); begin = orIfInvalid(begin, ann); + break; + } + default: + jj_la1[6] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return new ModifierHolder(begin, modifiers, annotations); +} + +/* + * Declaration syntax follows. + */ + final public +ClassOrInterfaceDeclaration ClassOrInterfaceDeclaration(ModifierHolder modifier) throws ParseException {boolean isInterface = false; + SimpleName name; + RangedList typePar = new RangedList(emptyList()); + NodeList extList = emptyList(); + NodeList impList = emptyList(); + NodeList> members = emptyList(); + JavaToken begin = modifier.begin; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case CLASS:{ + jj_consume_token(CLASS); + break; + } + case INTERFACE:{ + jj_consume_token(INTERFACE); +isInterface = true; + break; + } + default: + jj_la1[7] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +begin = orIfInvalid(begin, token()); + name = SimpleName(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typePar = TypeParameters(); + break; + } + default: + jj_la1[8] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case EXTENDS:{ + extList = ExtendsList(); + break; + } + default: + jj_la1[9] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case IMPLEMENTS:{ + impList = ImplementsList(); + break; + } + default: + jj_la1[10] = jj_gen; + ; + } + members = ClassOrInterfaceBody(); +return new ClassOrInterfaceDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, isInterface, name, typePar.list, extList, impList, members); +} + + final public NodeList ExtendsList() throws ParseException {boolean extendsMoreThanOne = false; + NodeList ret = new NodeList(); + ClassOrInterfaceType cit; + jj_consume_token(EXTENDS); + cit = AnnotatedClassOrInterfaceType(); +ret.add(cit); + label_4: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[11] = jj_gen; + break label_4; + } + jj_consume_token(COMMA); + cit = AnnotatedClassOrInterfaceType(); +ret.add(cit); extendsMoreThanOne = true; + } +return ret; +} + + final public NodeList ImplementsList() throws ParseException {NodeList ret = new NodeList(); + ClassOrInterfaceType cit; + jj_consume_token(IMPLEMENTS); + cit = AnnotatedClassOrInterfaceType(); +ret.add(cit); + label_5: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[12] = jj_gen; + break label_5; + } + jj_consume_token(COMMA); + cit = AnnotatedClassOrInterfaceType(); +ret.add(cit); + } +return ret; +} + + final public EnumDeclaration EnumDeclaration(ModifierHolder modifier) throws ParseException {SimpleName name; + NodeList impList = emptyList(); + EnumConstantDeclaration entry; + NodeList entries = emptyList(); + BodyDeclaration member; + NodeList> members = emptyList(); + JavaToken begin = modifier.begin; + jj_consume_token(ENUM); +begin = orIfInvalid(begin, token()); + name = SimpleName(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case IMPLEMENTS:{ + impList = ImplementsList(); + break; + } + default: + jj_la1[13] = jj_gen; + ; + } + jj_consume_token(LBRACE); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ENUM: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case AT:{ + entry = EnumConstantDeclaration(); +entries.add(entry); + label_6: + while (true) { + if (jj_2_4(2)) { + ; + } else { + break label_6; + } + jj_consume_token(COMMA); + entry = EnumConstantDeclaration(); +entries.add(entry); + } + break; + } + default: + jj_la1[14] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + jj_consume_token(COMMA); + break; + } + default: + jj_la1[15] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case SEMICOLON:{ + jj_consume_token(SEMICOLON); + label_7: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case CLASS: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case INTERFACE: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOID: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case LBRACE: + case SEMICOLON: + case AT: + case LT:{ + ; + break; + } + default: + jj_la1[16] = jj_gen; + break label_7; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case CLASS: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case INTERFACE: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOID: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case LBRACE: + case AT: + case LT:{ + member = ClassOrInterfaceBodyDeclaration(); +members = add(members, member); + break; + } + case SEMICOLON:{ + jj_consume_token(SEMICOLON); + break; + } + default: + jj_la1[17] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + break; + } + default: + jj_la1[18] = jj_gen; + ; + } + jj_consume_token(RBRACE); +return new EnumDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, name, impList, entries, members); +} + + final public EnumConstantDeclaration EnumConstantDeclaration() throws ParseException {NodeList annotations = new NodeList(); + AnnotationExpr ann; + SimpleName name; + NodeList args = emptyList(); + NodeList> classBody = emptyList(); + JavaToken begin = INVALID; + + label_8: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case AT:{ + ; + break; + } + default: + jj_la1[19] = jj_gen; + break label_8; + } + ann = Annotation(); +annotations = add(annotations, ann); begin = orIfInvalid(begin, ann); + } + name = SimpleName(); +begin = orIfInvalid(begin, token()); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LPAREN:{ + args = Arguments(); + break; + } + default: + jj_la1[20] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LBRACE:{ + classBody = ClassOrInterfaceBody(); + break; + } + default: + jj_la1[21] = jj_gen; + ; + } +return new EnumConstantDeclaration(range(begin, token()), annotations, name, args, classBody); +} + +/** + * If the list inside the returned RangedList is null, there are no brackets. + * If it is empty, there are brackets, but nothing is in them <>. + * The normal case is that it contains TypeParameters, like . + */ + final public RangedList TypeParameters() throws ParseException {RangedList ret = new RangedList(new NodeList()); + TypeParameter tp; + NodeList annotations; + jj_consume_token(LT); +ret.beginAt(token()); + annotations = Annotations(); + tp = TypeParameter(annotations); +ret.add(tp); annotations = null; + label_9: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[22] = jj_gen; + break label_9; + } + jj_consume_token(COMMA); + annotations = Annotations(); + tp = TypeParameter(annotations); +ret.add(tp); annotations = null; + } + jj_consume_token(GT); +ret.endAt(token()); +return ret; +} + + final public TypeParameter TypeParameter(NodeList annotations) throws ParseException {SimpleName name; + NodeList typeBound = emptyList(); + JavaToken begin; + name = SimpleName(); +begin=token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case EXTENDS:{ + typeBound = TypeBound(); + break; + } + default: + jj_la1[23] = jj_gen; + ; + } +return new TypeParameter(range(begin, token()), name, typeBound, annotations); +} + + final public NodeList TypeBound() throws ParseException {NodeList ret = emptyList(); + ClassOrInterfaceType cit; + jj_consume_token(EXTENDS); + cit = AnnotatedClassOrInterfaceType(); +ret.add(cit); + label_10: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BIT_AND:{ + ; + break; + } + default: + jj_la1[24] = jj_gen; + break label_10; + } + jj_consume_token(BIT_AND); + cit = AnnotatedClassOrInterfaceType(); +ret.add(cit); + } +return ret; +} + + final public NodeList> ClassOrInterfaceBody() throws ParseException {NodeList> ret = emptyList(); + BodyDeclaration member; + jj_consume_token(LBRACE); + label_11: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case CLASS: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case INTERFACE: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOID: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case LBRACE: + case SEMICOLON: + case AT: + case LT:{ + ; + break; + } + default: + jj_la1[25] = jj_gen; + break label_11; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case CLASS: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case INTERFACE: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOID: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case LBRACE: + case AT: + case LT:{ + member = ClassOrInterfaceBodyDeclaration(); +ret.add(member); + break; + } + case SEMICOLON:{ + jj_consume_token(SEMICOLON); + break; + } + default: + jj_la1[26] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + jj_consume_token(RBRACE); +return ret; +} + + final public BodyDeclaration ClassOrInterfaceBodyDeclaration() throws ParseException {ModifierHolder modifier; + BodyDeclaration ret; + if (jj_2_9(2)) { + ret = InitializerDeclaration(); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case CLASS: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case INTERFACE: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOID: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case AT: + case LT:{ + // Just get all the modifiers out of the way. If you want to do + // more checks, pass the modifiers down to the member + modifier = Modifiers(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case CLASS: + case INTERFACE:{ + ret = ClassOrInterfaceDeclaration(modifier); + break; + } + default: + jj_la1[27] = jj_gen; + if (jj_2_5(2147483647)) { + ret = EnumDeclaration(modifier); + } else if (jj_2_6(2147483647)) { + ret = AnnotationTypeDeclaration(modifier); + } else if (jj_2_7(2147483647)) { + ret = ConstructorDeclaration(modifier); + } else if (jj_2_8(2147483647)) { + ret = FieldDeclaration(modifier); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FLOAT: + case INT: + case LONG: + case SHORT: + case STRICTFP: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case AT: + case LT:{ + ret = MethodDeclaration(modifier); + break; + } + default: + jj_la1[28] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } + break; + } + default: + jj_la1[29] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return ret; +} + + final public FieldDeclaration FieldDeclaration(ModifierHolder modifier) throws ParseException {Type partialType; + NodeList variables = new NodeList(); + VariableDeclarator val; + // Modifiers are already matched in the caller + partialType = Type(emptyList()); + val = VariableDeclarator(partialType); +variables.add(val); + label_12: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[30] = jj_gen; + break label_12; + } + jj_consume_token(COMMA); + val = VariableDeclarator(partialType); +variables.add(val); + } + jj_consume_token(SEMICOLON); +JavaToken begin = orIfInvalid(modifier.begin, partialType); + return new FieldDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, variables); +} + + final public VariableDeclarator VariableDeclarator(Type partialType) throws ParseException {Pair> id; + Expression init = null; + id = VariableDeclaratorId(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ASSIGN:{ + jj_consume_token(ASSIGN); + init = VariableInitializer(); + break; + } + default: + jj_la1[31] = jj_gen; + ; + } +return new VariableDeclarator(range(id.a, token()), juggleArrayType(partialType, id.b), id.a, init); +} + + final public Pair> VariableDeclaratorId() throws ParseException {SimpleName name; + JavaToken begin; + ArrayBracketPair arrayBracketPair; + List arrayBracketPairs = new ArrayList(0); + name = SimpleName(); +begin=token(); + label_13: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LBRACKET: + case AT:{ + ; + break; + } + default: + jj_la1[32] = jj_gen; + break label_13; + } + arrayBracketPair = ArrayBracketPair(Origin.NAME); +arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); + } +if(storeTokens) { + name.setTokenRange(name.getTokenRange().get().withEnd(token())); + } + return new Pair(name, arrayBracketPairs); +} + + final public Expression VariableInitializer() throws ParseException {Expression ret; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LBRACE:{ + ret = ArrayInitializer(); + break; + } + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + ret = Expression(); + break; + } + default: + jj_la1[33] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return ret; +} + + final public ArrayInitializerExpr ArrayInitializer() throws ParseException {NodeList values = emptyList(); + Expression val; + JavaToken begin; + jj_consume_token(LBRACE); +begin=token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case LBRACE: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + val = VariableInitializer(); +values = add(values, val); + label_14: + while (true) { + if (jj_2_10(2)) { + ; + } else { + break label_14; + } + jj_consume_token(COMMA); + val = VariableInitializer(); +values = add(values, val); + } + break; + } + default: + jj_la1[34] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + jj_consume_token(COMMA); + break; + } + default: + jj_la1[35] = jj_gen; + ; + } + jj_consume_token(RBRACE); +return new ArrayInitializerExpr(range(begin, token()), values); +} + + final public MethodDeclaration MethodDeclaration(ModifierHolder modifier) throws ParseException {RangedList typeParameters = new RangedList(emptyList()); + Type type; + SimpleName name; + Pair, ReceiverParameter> parameters = new Pair, ReceiverParameter>(emptyList(), null); + ArrayBracketPair arrayBracketPair; + List arrayBracketPairs = new ArrayList(0); + NodeList throws_ = emptyList(); + BlockStmt body = null; + NodeList annotations; + JavaToken begin = modifier.begin; + ReferenceType throwType; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typeParameters = TypeParameters(); +begin = orIfInvalid(begin, typeParameters.range.getBegin()); + break; + } + default: + jj_la1[36] = jj_gen; + ; + } + annotations = Annotations(); +modifier.annotations.addAll(annotations); begin = orIfInvalid(begin, nodeListBegin(annotations)); + type = ResultType(emptyList()); +begin = orIfInvalid(begin, type); + name = SimpleName(); + parameters = Parameters(); + label_15: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LBRACKET: + case AT:{ + ; + break; + } + default: + jj_la1[37] = jj_gen; + break label_15; + } + arrayBracketPair = ArrayBracketPair(Origin.NAME); +arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case THROWS:{ + jj_consume_token(THROWS); + throwType = AnnotatedReferenceType(); +throws_ = add(throws_, throwType); + label_16: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[38] = jj_gen; + break label_16; + } + jj_consume_token(COMMA); + throwType = AnnotatedReferenceType(); +throws_ = add(throws_, throwType); + } + break; + } + default: + jj_la1[39] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LBRACE:{ + body = Block(); + break; + } + case SEMICOLON:{ + jj_consume_token(SEMICOLON); + break; + } + default: + jj_la1[40] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +type = juggleArrayType(type, arrayBracketPairs); + return new MethodDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, typeParameters.list, type, name, parameters.a, throws_, body, parameters.b); +} + + final public ReferenceType AnnotatedReferenceType() throws ParseException {NodeList annotations; + ReferenceType type; + annotations = Annotations(); + type = ReferenceType(annotations); +return type; +} + + final public Type AnnotatedType() throws ParseException {NodeList annotations; + Type type; + annotations = Annotations(); + type = Type(annotations); +return type; +} + + final public Pair, ReceiverParameter> Parameters() throws ParseException {NodeList ret = emptyList(); + Parameter par; + ReceiverParameter rp = null; + jj_consume_token(LPAREN); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case AT:{ + if (jj_2_11(2147483647)) { + rp = ReceiverParameter(); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case AT:{ + par = Parameter(); +ret = add(ret, par); + break; + } + default: + jj_la1[41] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + label_17: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[42] = jj_gen; + break label_17; + } + jj_consume_token(COMMA); + par = Parameter(); +ret = add(ret, par); + } + break; + } + default: + jj_la1[43] = jj_gen; + ; + } + jj_consume_token(RPAREN); +return new Pair(ret, rp); +} + + final public NodeList LambdaParameters() throws ParseException {NodeList ret = null; + Parameter par; + par = Parameter(); +ret = add(ret, par); + label_18: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[44] = jj_gen; + break label_18; + } + jj_consume_token(COMMA); + par = Parameter(); +ret = add(ret, par); + } +return ret; +} + + final public NodeList InferredLambdaParameters() throws ParseException {NodeList ret = null; + Pair> id; + id = VariableDeclaratorId(); +ret = add(ret, new Parameter(range(id.a, id.a), EnumSet.noneOf(Modifier.class), emptyList(), new UnknownType(), false, emptyList(), id.a)); + label_19: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[45] = jj_gen; + break label_19; + } + jj_consume_token(COMMA); + id = VariableDeclaratorId(); +ret = add(ret, new Parameter(range(id.a, id.a), EnumSet.noneOf(Modifier.class), emptyList(), new UnknownType(), false, emptyList(), id.a)); + } +return ret; +} + + final public Parameter Parameter() throws ParseException {ModifierHolder modifier; + Type partialType; + boolean isVarArg = false; + Pair> id; + NodeList varArgAnnotations = emptyList(); + modifier = Modifiers(); + partialType = Type(emptyList()); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case AT: + case ELLIPSIS:{ + varArgAnnotations = Annotations(); + jj_consume_token(ELLIPSIS); +isVarArg = true; + break; + } + default: + jj_la1[46] = jj_gen; + ; + } + id = VariableDeclaratorId(); +JavaToken begin = orIfInvalid(modifier.begin, partialType); + return new Parameter(range(begin, token()), modifier.modifiers, modifier.annotations, juggleArrayType(partialType, id.b), isVarArg, varArgAnnotations, id.a); +} + + final public ReceiverParameter ReceiverParameter() throws ParseException {Type partialType; + Name id; + NodeList annotations = emptyList(); + annotations = Annotations(); + partialType = Type(emptyList()); + id = ReceiverParameterId(); +return new ReceiverParameter(range(partialType, token()), annotations, partialType, id); +} + + final public Name ReceiverParameterId() throws ParseException {Name ret = null; + NodeList annotations; + if (jj_2_12(2147483647)) { + ret = Name(); + jj_consume_token(DOT); + } else { + ; + } + annotations = Annotations(); + jj_consume_token(THIS); +return new Name(tokenRange(), ret, token.image, annotations); +} + + final public ConstructorDeclaration ConstructorDeclaration(ModifierHolder modifier) throws ParseException {RangedList typeParameters = new RangedList(emptyList()); + SimpleName name; + Pair, ReceiverParameter> parameters = new Pair, ReceiverParameter>(emptyList(), null); + NodeList throws_ = emptyList(); + ExplicitConstructorInvocationStmt exConsInv = null; + NodeList stmts = emptyList(); + JavaToken begin = modifier.begin; + JavaToken blockBegin = INVALID; + ReferenceType throwType; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typeParameters = TypeParameters(); +begin = orIfInvalid(begin, typeParameters.range.getBegin()); + break; + } + default: + jj_la1[47] = jj_gen; + ; + } + // Modifiers matched in the caller + name = SimpleName(); +begin = orIfInvalid(begin, typeParameters.range.getBegin()); begin = orIfInvalid(begin, token()); + parameters = Parameters(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case THROWS:{ + jj_consume_token(THROWS); + throwType = AnnotatedReferenceType(); +throws_ = add(throws_, throwType); + label_20: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[48] = jj_gen; + break label_20; + } + jj_consume_token(COMMA); + throwType = AnnotatedReferenceType(); +throws_ = add(throws_, throwType); + } + break; + } + default: + jj_la1[49] = jj_gen; + ; + } + jj_consume_token(LBRACE); +blockBegin=token(); + if (jj_2_13(2147483647)) { + exConsInv = ExplicitConstructorInvocation(); + } else { + ; + } + stmts = Statements(); + jj_consume_token(RBRACE); +if (exConsInv != null) { + stmts = prepend(stmts, exConsInv); + } + return new ConstructorDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, typeParameters.list, name, parameters.a, throws_, new BlockStmt(range(blockBegin, token()), stmts), parameters.b); +} + + final public ExplicitConstructorInvocationStmt ExplicitConstructorInvocation() throws ParseException {boolean isThis = false; + NodeList args; + Expression expr = null; + RangedList typeArgs = new RangedList(null); + JavaToken begin = INVALID; + if (jj_2_15(2147483647)) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typeArgs = TypeArguments(); +begin=typeArgs.range.getBegin(); + break; + } + default: + jj_la1[50] = jj_gen; + ; + } + jj_consume_token(THIS); +begin = orIfInvalid(begin, token()); isThis = true; + args = Arguments(); + jj_consume_token(SEMICOLON); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case LT:{ + if (jj_2_14(2147483647)) { + expr = PrimaryExpressionWithoutSuperSuffix(); + jj_consume_token(DOT); +begin = orIfInvalid(begin, expr); + } else { + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typeArgs = TypeArguments(); +begin = orIfInvalid(begin, typeArgs.range.getBegin()); + break; + } + default: + jj_la1[51] = jj_gen; + ; + } + jj_consume_token(SUPER); +begin = orIfInvalid(begin, token()); + args = Arguments(); + jj_consume_token(SEMICOLON); + break; + } + default: + jj_la1[52] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return new ExplicitConstructorInvocationStmt(range(begin, token()),typeArgs.list, isThis, expr, args); +} + + final public NodeList Statements() throws ParseException {NodeList ret = emptyList(); + Statement stmt; + label_21: + while (true) { + if (jj_2_16(2)) { + ; + } else { + break label_21; + } + stmt = BlockStatement(); +ret = add(ret, stmt); + } +return ret; +} + + final public InitializerDeclaration InitializerDeclaration() throws ParseException {BlockStmt body; + JavaToken begin = INVALID; + boolean isStatic = false; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case STATIC:{ + jj_consume_token(STATIC); +isStatic = true; begin=token(); + break; + } + default: + jj_la1[53] = jj_gen; + ; + } + body = Block(); +begin = orIfInvalid(begin, body); +return new InitializerDeclaration(range(begin, token()), isStatic, body); +} + +/* + * Type, name and expression syntax follows. + */ + final public +Type Type(NodeList annotations) throws ParseException {Type ret; + if (jj_2_17(2)) { + ret = ReferenceType(annotations); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT:{ + ret = PrimitiveType(annotations); + break; + } + default: + jj_la1[54] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return ret; +} + + final public ReferenceType ReferenceType(NodeList annotations) throws ParseException {Type type; + ArrayBracketPair arrayBracketPair; + List arrayBracketPairs = new ArrayList(0); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT:{ + type = PrimitiveType(annotations); + label_22: + while (true) { + arrayBracketPair = ArrayBracketPair(Origin.TYPE); +arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); + if (jj_2_18(2147483647)) { + ; + } else { + break label_22; + } + } + break; + } + case ENUM: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + type = ClassOrInterfaceType(annotations); + label_23: + while (true) { + if (jj_2_19(2147483647)) { + ; + } else { + break label_23; + } + arrayBracketPair = ArrayBracketPair(Origin.TYPE); +arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair); + } + break; + } + default: + jj_la1[55] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return (ReferenceType)wrapInArrayTypes(type, arrayBracketPairs); +} + + final public ArrayBracketPair ArrayBracketPair(Origin origin) throws ParseException {NodeList annotations; + JavaToken begin = INVALID; + annotations = Annotations(); + jj_consume_token(LBRACKET); +begin = orIfInvalid(begin, token()); + jj_consume_token(RBRACKET); +return new ArrayBracketPair(range(begin, token()), origin, annotations); +} + + final public IntersectionType IntersectionType(NodeList annotations) throws ParseException {JavaToken begin = INVALID; + ReferenceType elementType; + NodeList elements = emptyList(); + elementType = ReferenceType(annotations); +begin = orIfInvalid(begin, elementType); elements = add(elements, elementType); + jj_consume_token(BIT_AND); + label_24: + while (true) { + elementType = AnnotatedReferenceType(); +elements = add(elements, elementType); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FLOAT: + case INT: + case LONG: + case SHORT: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case AT:{ + ; + break; + } + default: + jj_la1[56] = jj_gen; + break label_24; + } + } +return new IntersectionType(range(begin, token()), elements); +} + + final public ClassOrInterfaceType AnnotatedClassOrInterfaceType() throws ParseException {NodeList annotations = new NodeList(); + ClassOrInterfaceType cit; + annotations = Annotations(); + cit = ClassOrInterfaceType(annotations); +return cit; +} + + final public ClassOrInterfaceType ClassOrInterfaceType(NodeList firstAnnotations) throws ParseException {ClassOrInterfaceType ret; + SimpleName name; + RangedList typeArgs = new RangedList(null); + JavaToken begin; + NodeList annotations = new NodeList(); + name = SimpleName(); +begin=token(); + if (jj_2_20(2)) { + typeArgs = TypeArguments(); + } else { + ; + } +ret = new ClassOrInterfaceType(range(begin, token()), null, name, typeArgs.list, firstAnnotations); + typeArgs = new RangedList(null); + label_25: + while (true) { + if (jj_2_21(2)) { + ; + } else { + break label_25; + } + jj_consume_token(DOT); + annotations = Annotations(); + name = SimpleName(); + if (jj_2_22(2)) { + typeArgs = TypeArguments(); + } else { + ; + } +ret = new ClassOrInterfaceType(range(begin, token()), ret, name, typeArgs.list, annotations); + typeArgs = new RangedList(null); + } +return ret; +} + + final public RangedList TypeArguments() throws ParseException {RangedList ret = new RangedList(new NodeList()); + Type type; + jj_consume_token(LT); +ret.beginAt(token()); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FLOAT: + case INT: + case LONG: + case SHORT: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case AT: + case HOOK:{ + type = TypeArgument(); +ret.add(type); + label_26: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[57] = jj_gen; + break label_26; + } + jj_consume_token(COMMA); + type = TypeArgument(); +ret.add(type); + } + break; + } + default: + jj_la1[58] = jj_gen; + ; + } + jj_consume_token(GT); +ret.endAt(token()); +return ret; +} + + final public Type TypeArgument() throws ParseException {Type ret; + NodeList annotations; + annotations = Annotations(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FLOAT: + case INT: + case LONG: + case SHORT: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + ret = Type(annotations); + break; + } + case HOOK:{ + ret = Wildcard(annotations); + break; + } + default: + jj_la1[59] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return ret; +} + + final public WildcardType Wildcard(NodeList firstAnnotations) throws ParseException {ReferenceType ext = null; + ReferenceType sup = null; + JavaToken begin; + NodeList annotations = new NodeList(); + jj_consume_token(HOOK); +begin=token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case EXTENDS: + case SUPER:{ + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case EXTENDS:{ + jj_consume_token(EXTENDS); + annotations = Annotations(); + ext = ReferenceType(annotations); + break; + } + case SUPER:{ + jj_consume_token(SUPER); + annotations = Annotations(); + sup = ReferenceType(annotations); + break; + } + default: + jj_la1[60] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + break; + } + default: + jj_la1[61] = jj_gen; + ; + } +return new WildcardType(range(begin, token()), ext, sup, firstAnnotations); +} + + final public PrimitiveType PrimitiveType(NodeList annotations) throws ParseException {PrimitiveType ret; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN:{ + jj_consume_token(BOOLEAN); +ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.BOOLEAN, annotations); + break; + } + case CHAR:{ + jj_consume_token(CHAR); +ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.CHAR, annotations); + break; + } + case BYTE:{ + jj_consume_token(BYTE); +ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.BYTE, annotations); + break; + } + case SHORT:{ + jj_consume_token(SHORT); +ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.SHORT, annotations); + break; + } + case INT:{ + jj_consume_token(INT); +ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.INT, annotations); + break; + } + case LONG:{ + jj_consume_token(LONG); +ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.LONG, annotations); + break; + } + case FLOAT:{ + jj_consume_token(FLOAT); +ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.FLOAT, annotations); + break; + } + case DOUBLE:{ + jj_consume_token(DOUBLE); +ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.DOUBLE, annotations); + break; + } + default: + jj_la1[62] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return ret; +} + + final public Type ResultType(NodeList annotations) throws ParseException {Type ret; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case VOID:{ + jj_consume_token(VOID); +ret = new VoidType(tokenRange()); + break; + } + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FLOAT: + case INT: + case LONG: + case SHORT: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + ret = Type(annotations); + break; + } + default: + jj_la1[63] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return ret; +} + + final public Name Name() throws ParseException {Name ret; + NodeList annotations = new NodeList(); + annotations = Annotations(); + Identifier(); +ret = new Name(tokenRange(), null, token.image, annotations); + label_27: + while (true) { + if (jj_2_23(2147483647)) { + ; + } else { + break label_27; + } + jj_consume_token(DOT); + annotations = Annotations(); + Identifier(); +ret = new Name(range(ret, token()), ret, token.image, annotations); + } +return ret; +} + + final public SimpleName SimpleName() throws ParseException {SimpleName ret; + Identifier(); +ret = new SimpleName(tokenRange(), token.image); +return ret; +} + + final public String Identifier() throws ParseException {String ret; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case MODULE:{ + jj_consume_token(MODULE); + break; + } + case REQUIRES:{ + jj_consume_token(REQUIRES); + break; + } + case TO:{ + jj_consume_token(TO); + break; + } + case WITH:{ + jj_consume_token(WITH); + break; + } + case OPEN:{ + jj_consume_token(OPEN); + break; + } + case OPENS:{ + jj_consume_token(OPENS); + break; + } + case USES:{ + jj_consume_token(USES); + break; + } + case EXPORTS:{ + jj_consume_token(EXPORTS); + break; + } + case PROVIDES:{ + jj_consume_token(PROVIDES); + break; + } + case TRANSITIVE:{ + jj_consume_token(TRANSITIVE); + break; + } + case ENUM:{ + jj_consume_token(ENUM); + break; + } + case STRICTFP:{ + jj_consume_token(STRICTFP); + break; + } + case IDENTIFIER:{ + jj_consume_token(IDENTIFIER); + break; + } + default: + jj_la1[64] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +ret = token.image; setTokenKind(IDENTIFIER); +return ret; +} + +/* + * Expression syntax follows. + */ + final public +Expression Expression() throws ParseException {Expression ret; + AssignExpr.Operator op; + Expression value; + Statement lambdaBody = null; + RangedList typeArgs = new RangedList(null); + ret = ConditionalExpression(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ASSIGN: + case PLUSASSIGN: + case MINUSASSIGN: + case STARASSIGN: + case SLASHASSIGN: + case ANDASSIGN: + case ORASSIGN: + case XORASSIGN: + case REMASSIGN: + case LSHIFTASSIGN: + case RSIGNEDSHIFTASSIGN: + case RUNSIGNEDSHIFTASSIGN: + case ARROW: + case DOUBLECOLON:{ + if (jj_2_24(2)) { + op = AssignmentOperator(); + value = Expression(); +ret = new AssignExpr(range(ret, token()), ret, value, op); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ARROW:{ + jj_consume_token(ARROW); + lambdaBody = LambdaBody(); +if (ret instanceof CastExpr) { + ret = generateLambda(ret, lambdaBody); + } else if (ret instanceof ConditionalExpr) { + ConditionalExpr ce = (ConditionalExpr) ret; + if(ce.getElseExpr() != null) { + ce.setElseExpr(generateLambda(ce.getElseExpr(), lambdaBody)); + } + } else { + ret = generateLambda(ret, lambdaBody); + } + break; + } + case DOUBLECOLON:{ + jj_consume_token(DOUBLECOLON); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typeArgs = TypeArguments(); + break; + } + default: + jj_la1[65] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ENUM: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + Identifier(); + break; + } + case NEW:{ + jj_consume_token(NEW); + break; + } + default: + jj_la1[66] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image); + break; + } + default: + jj_la1[67] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + break; + } + default: + jj_la1[68] = jj_gen; + ; + } +return ret; +} + + final public AssignExpr.Operator AssignmentOperator() throws ParseException {AssignExpr.Operator ret; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ASSIGN:{ + jj_consume_token(ASSIGN); +ret = AssignExpr.Operator.ASSIGN; + break; + } + case STARASSIGN:{ + jj_consume_token(STARASSIGN); +ret = AssignExpr.Operator.MULTIPLY; + break; + } + case SLASHASSIGN:{ + jj_consume_token(SLASHASSIGN); +ret = AssignExpr.Operator.DIVIDE; + break; + } + case REMASSIGN:{ + jj_consume_token(REMASSIGN); +ret = AssignExpr.Operator.REMAINDER; + break; + } + case PLUSASSIGN:{ + jj_consume_token(PLUSASSIGN); +ret = AssignExpr.Operator.PLUS; + break; + } + case MINUSASSIGN:{ + jj_consume_token(MINUSASSIGN); +ret = AssignExpr.Operator.MINUS; + break; + } + case LSHIFTASSIGN:{ + jj_consume_token(LSHIFTASSIGN); +ret = AssignExpr.Operator.LEFT_SHIFT; + break; + } + case RSIGNEDSHIFTASSIGN:{ + jj_consume_token(RSIGNEDSHIFTASSIGN); +ret = AssignExpr.Operator.SIGNED_RIGHT_SHIFT; + break; + } + case RUNSIGNEDSHIFTASSIGN:{ + jj_consume_token(RUNSIGNEDSHIFTASSIGN); +ret = AssignExpr.Operator.UNSIGNED_RIGHT_SHIFT; + break; + } + case ANDASSIGN:{ + jj_consume_token(ANDASSIGN); +ret = AssignExpr.Operator.BINARY_AND; + break; + } + case XORASSIGN:{ + jj_consume_token(XORASSIGN); +ret = AssignExpr.Operator.XOR; + break; + } + case ORASSIGN:{ + jj_consume_token(ORASSIGN); +ret = AssignExpr.Operator.BINARY_OR; + break; + } + default: + jj_la1[69] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return ret; +} + + final public Expression ConditionalExpression() throws ParseException {Expression ret; + Expression left; + Expression right; + ret = ConditionalOrExpression(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case HOOK:{ + jj_consume_token(HOOK); + left = Expression(); + jj_consume_token(COLON); + right = ConditionalExpression(); +ret = new ConditionalExpr(range(ret, token()), ret, left, right); + break; + } + default: + jj_la1[70] = jj_gen; + ; + } +return ret; +} + + final public Expression ConditionalOrExpression() throws ParseException {Expression ret; + Expression right; + ret = ConditionalAndExpression(); + label_28: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case SC_OR:{ + ; + break; + } + default: + jj_la1[71] = jj_gen; + break label_28; + } + jj_consume_token(SC_OR); + right = ConditionalAndExpression(); +ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.OR); + } +return ret; +} + + final public Expression ConditionalAndExpression() throws ParseException {Expression ret; + Expression right; + ret = InclusiveOrExpression(); + label_29: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case SC_AND:{ + ; + break; + } + default: + jj_la1[72] = jj_gen; + break label_29; + } + jj_consume_token(SC_AND); + right = InclusiveOrExpression(); +ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.AND); + } +return ret; +} + + final public Expression InclusiveOrExpression() throws ParseException {Expression ret; + Expression right; + ret = ExclusiveOrExpression(); + label_30: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BIT_OR:{ + ; + break; + } + default: + jj_la1[73] = jj_gen; + break label_30; + } + jj_consume_token(BIT_OR); + right = ExclusiveOrExpression(); +ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.BINARY_OR); + } +return ret; +} + + final public Expression ExclusiveOrExpression() throws ParseException {Expression ret; + Expression right; + ret = AndExpression(); + label_31: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case XOR:{ + ; + break; + } + default: + jj_la1[74] = jj_gen; + break label_31; + } + jj_consume_token(XOR); + right = AndExpression(); +ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.XOR); + } +return ret; +} + + final public Expression AndExpression() throws ParseException {Expression ret; + Expression right; + ret = EqualityExpression(); + label_32: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BIT_AND:{ + ; + break; + } + default: + jj_la1[75] = jj_gen; + break label_32; + } + jj_consume_token(BIT_AND); + right = EqualityExpression(); +ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.BINARY_AND); + } +return ret; +} + + final public Expression EqualityExpression() throws ParseException {Expression ret; + Expression right; + BinaryExpr.Operator op; + ret = InstanceOfExpression(); + label_33: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case EQ: + case NE:{ + ; + break; + } + default: + jj_la1[76] = jj_gen; + break label_33; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case EQ:{ + jj_consume_token(EQ); +op = BinaryExpr.Operator.EQUALS; + break; + } + case NE:{ + jj_consume_token(NE); +op = BinaryExpr.Operator.NOT_EQUALS; + break; + } + default: + jj_la1[77] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + right = InstanceOfExpression(); +ret = new BinaryExpr(range(ret, token()), ret, right, op); + } +return ret; +} + + final public Expression InstanceOfExpression() throws ParseException {Expression ret; + ReferenceType type; + NodeList annotations; + ret = RelationalExpression(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case INSTANCEOF:{ + jj_consume_token(INSTANCEOF); + type = AnnotatedReferenceType(); +ret = new InstanceOfExpr(range(ret, token()), ret, type); + break; + } + default: + jj_la1[78] = jj_gen; + ; + } +return ret; +} + + final public Expression RelationalExpression() throws ParseException {Expression ret; + Expression right; + BinaryExpr.Operator op; + ret = ShiftExpression(); + label_34: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT: + case LE: + case GE: + case GT:{ + ; + break; + } + default: + jj_la1[79] = jj_gen; + break label_34; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + jj_consume_token(LT); +op = BinaryExpr.Operator.LESS; + break; + } + case GT:{ + jj_consume_token(GT); +op = BinaryExpr.Operator.GREATER; + break; + } + case LE:{ + jj_consume_token(LE); +op = BinaryExpr.Operator.LESS_EQUALS; + break; + } + case GE:{ + jj_consume_token(GE); +op = BinaryExpr.Operator.GREATER_EQUALS; + break; + } + default: + jj_la1[80] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + right = ShiftExpression(); +ret = new BinaryExpr(range(ret, token()), ret, right, op); + } +return ret; +} + + final public Expression ShiftExpression() throws ParseException {Expression ret; + Expression right; + BinaryExpr.Operator op; + ret = AdditiveExpression(); + label_35: + while (true) { + if (jj_2_25(1)) { + ; + } else { + break label_35; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LSHIFT:{ + jj_consume_token(LSHIFT); +op = BinaryExpr.Operator.LEFT_SHIFT; + break; + } + default: + jj_la1[81] = jj_gen; + if (jj_2_26(1)) { + RSIGNEDSHIFT(); +op = BinaryExpr.Operator.SIGNED_RIGHT_SHIFT; + } else if (jj_2_27(1)) { + RUNSIGNEDSHIFT(); +op = BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT; + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + right = AdditiveExpression(); +ret = new BinaryExpr(range(ret, token()), ret, right, op); + } +return ret; +} + + final public Expression AdditiveExpression() throws ParseException {Expression ret; + Expression right; + BinaryExpr.Operator op; + ret = MultiplicativeExpression(); + label_36: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case PLUS: + case MINUS:{ + ; + break; + } + default: + jj_la1[82] = jj_gen; + break label_36; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case PLUS:{ + jj_consume_token(PLUS); +op = BinaryExpr.Operator.PLUS; + break; + } + case MINUS:{ + jj_consume_token(MINUS); +op = BinaryExpr.Operator.MINUS; + break; + } + default: + jj_la1[83] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + right = MultiplicativeExpression(); +ret = new BinaryExpr(range(ret, token()), ret, right, op); + } +return ret; +} + + final public Expression MultiplicativeExpression() throws ParseException {Expression ret; + Expression right; + BinaryExpr.Operator op; + ret = UnaryExpression(); + label_37: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case STAR: + case SLASH: + case REM:{ + ; + break; + } + default: + jj_la1[84] = jj_gen; + break label_37; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case STAR:{ + jj_consume_token(STAR); +op = BinaryExpr.Operator.MULTIPLY; + break; + } + case SLASH:{ + jj_consume_token(SLASH); +op = BinaryExpr.Operator.DIVIDE; + break; + } + case REM:{ + jj_consume_token(REM); +op = BinaryExpr.Operator.REMAINDER; + break; + } + default: + jj_la1[85] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + right = UnaryExpression(); +ret = new BinaryExpr(range(ret, token()), ret, right, op); + } +return ret; +} + + final public Expression UnaryExpression() throws ParseException {Expression ret; + UnaryExpr.Operator op; + JavaToken begin = INVALID; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case INCR:{ + ret = PreIncrementExpression(); + break; + } + case DECR:{ + ret = PreDecrementExpression(); + break; + } + case PLUS: + case MINUS:{ + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case PLUS:{ + jj_consume_token(PLUS); +op = UnaryExpr.Operator.PLUS; begin=token(); + break; + } + case MINUS:{ + jj_consume_token(MINUS); +op = UnaryExpr.Operator.MINUS; begin=token(); + break; + } + default: + jj_la1[86] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + ret = UnaryExpression(); +ret = new UnaryExpr(range(begin, token()), ret, op); + break; + } + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE:{ + ret = UnaryExpressionNotPlusMinus(); + break; + } + default: + jj_la1[87] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return ret; +} + + final public Expression PreIncrementExpression() throws ParseException {Expression ret; + JavaToken begin = INVALID; + jj_consume_token(INCR); +begin=token(); + ret = UnaryExpression(); +ret = new UnaryExpr(range(begin, token()), ret, UnaryExpr.Operator.PREFIX_INCREMENT); +return ret; +} + + final public Expression PreDecrementExpression() throws ParseException {Expression ret; + JavaToken begin; + jj_consume_token(DECR); +begin=token(); + ret = UnaryExpression(); +ret = new UnaryExpr(range(begin, token()), ret, UnaryExpr.Operator.PREFIX_DECREMENT); +return ret; +} + + final public Expression UnaryExpressionNotPlusMinus() throws ParseException {Expression ret; + UnaryExpr.Operator op; + JavaToken begin = INVALID; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BANG: + case TILDE:{ + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case TILDE:{ + jj_consume_token(TILDE); +op = UnaryExpr.Operator.BITWISE_COMPLEMENT; begin=token(); + break; + } + case BANG:{ + jj_consume_token(BANG); +op = UnaryExpr.Operator.LOGICAL_COMPLEMENT; begin=token(); + break; + } + default: + jj_la1[88] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + ret = UnaryExpression(); +ret = new UnaryExpr(range(begin, token()), ret, op); + break; + } + default: + jj_la1[89] = jj_gen; + if (jj_2_28(2147483647)) { + ret = CastExpression(); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT:{ + ret = PostfixExpression(); + break; + } + default: + jj_la1[90] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } +return ret; +} + + final public Expression PostfixExpression() throws ParseException {Expression ret; + UnaryExpr.Operator op; + ret = PrimaryExpression(); + if (jj_2_29(2)) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case INCR:{ + jj_consume_token(INCR); +op = UnaryExpr.Operator.POSTFIX_INCREMENT; + break; + } + case DECR:{ + jj_consume_token(DECR); +op = UnaryExpr.Operator.POSTFIX_DECREMENT; + break; + } + default: + jj_la1[91] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +ret = new UnaryExpr(range(ret, token()), ret, op); + } else { + ; + } +return ret; +} + + final public Expression CastExpression() throws ParseException {Expression ret; + ReferenceType referenceType; + PrimitiveType primitiveType; + JavaToken begin = INVALID; + NodeList annotations; + NodeList typesOfMultiCast = emptyList(); + jj_consume_token(LPAREN); +begin=token(); + annotations = Annotations(); + if (jj_2_30(2)) { + primitiveType = PrimitiveType(annotations); + jj_consume_token(RPAREN); + ret = UnaryExpression(); +ret = new CastExpr(range(begin, token()), primitiveType, ret); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FLOAT: + case INT: + case LONG: + case SHORT: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + referenceType = ReferenceType(annotations); +typesOfMultiCast = add(typesOfMultiCast, referenceType); + label_38: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BIT_AND:{ + ; + break; + } + default: + jj_la1[92] = jj_gen; + break label_38; + } + jj_consume_token(BIT_AND); + referenceType = AnnotatedReferenceType(); +typesOfMultiCast = add(typesOfMultiCast, referenceType); + } + jj_consume_token(RPAREN); + ret = UnaryExpressionNotPlusMinus(); +if (typesOfMultiCast.size() > 1) { + ret = new CastExpr(range(begin, token()), new IntersectionType(range(typesOfMultiCast.get(0), typesOfMultiCast.get(typesOfMultiCast.size() -1)), typesOfMultiCast), ret); + } else { + ret = new CastExpr(range(begin, token()), referenceType, ret); + } + break; + } + default: + jj_la1[93] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return ret; +} + + final public Expression PrimaryExpression() throws ParseException {Expression ret; + ret = PrimaryPrefix(); + label_39: + while (true) { + if (jj_2_31(2)) { + ; + } else { + break label_39; + } + ret = PrimarySuffix(ret); + } +return ret; +} + + final public Expression PrimaryExpressionWithoutSuperSuffix() throws ParseException {Expression ret; + ret = PrimaryPrefix(); + label_40: + while (true) { + if (jj_2_32(2147483647)) { + ; + } else { + break label_40; + } + ret = PrimarySuffixWithoutSuper(ret); + } +return ret; +} + + final public Expression PrimaryPrefix() throws ParseException {Expression ret = null; + SimpleName name; + RangedList typeArgs = new RangedList(null); + NodeList args = emptyList(); + NodeList params = emptyList(); + boolean hasArgs = false; + boolean isLambda = false; + Type type; + JavaToken begin; + Parameter p = null; + SimpleName id = null; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case FALSE: + case NULL: + case TRUE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL:{ + ret = Literal(); + break; + } + case THIS:{ + jj_consume_token(THIS); +ret = new ThisExpr(tokenRange(), null); + break; + } + case SUPER:{ + jj_consume_token(SUPER); +ret = new SuperExpr(tokenRange(), null); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case DOT:{ + jj_consume_token(DOT); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typeArgs = TypeArguments(); + break; + } + default: + jj_la1[94] = jj_gen; + ; + } + name = SimpleName(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LPAREN:{ + args = Arguments(); +hasArgs=true; + break; + } + default: + jj_la1[95] = jj_gen; + ; + } +if (hasArgs) { + ret = new MethodCallExpr(range(ret, token()), ret, typeArgs.list, name, args); + } else { + ret = new FieldAccessExpr(range(ret, token()), ret, emptyList(), name); + } + break; + } + case DOUBLECOLON:{ + jj_consume_token(DOUBLECOLON); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typeArgs = TypeArguments(); + break; + } + default: + jj_la1[96] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ENUM: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + Identifier(); + break; + } + case NEW:{ + jj_consume_token(NEW); + break; + } + default: + jj_la1[97] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image); + break; + } + default: + jj_la1[98] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + break; + } + case LPAREN:{ + jj_consume_token(LPAREN); +begin=token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case RPAREN:{ + jj_consume_token(RPAREN); +ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true); + break; + } + default: + jj_la1[99] = jj_gen; + if (jj_2_33(2147483647)) { + params = LambdaParameters(); + jj_consume_token(RPAREN); +ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true); + } else if (jj_2_34(2147483647)) { + params = InferredLambdaParameters(); + jj_consume_token(RPAREN); +ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + // This could still be a lambda expression, but this is handled after matching -> elsewhere + ret = Expression(); + jj_consume_token(RPAREN); +ret = new EnclosedExpr(range(begin, token()), ret); + break; + } + default: + jj_la1[100] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } + break; + } + case NEW:{ + ret = AllocationExpression(null); + break; + } + default: + jj_la1[104] = jj_gen; + if (jj_2_35(2147483647)) { + type = ResultType(emptyList()); + jj_consume_token(DOT); + jj_consume_token(CLASS); +ret = new ClassExpr(range(type, token()), type); + } else if (jj_2_36(2147483647)) { + type = AnnotatedType(); + jj_consume_token(DOUBLECOLON); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typeArgs = TypeArguments(); + break; + } + default: + jj_la1[101] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ENUM: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + Identifier(); + break; + } + case NEW:{ + jj_consume_token(NEW); + break; + } + default: + jj_la1[102] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +ret = new TypeExpr(range(type, type), type); + ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ENUM: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + name = SimpleName(); +begin=token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LPAREN:{ + args = Arguments(); +hasArgs=true; + break; + } + default: + jj_la1[103] = jj_gen; + ; + } +if (hasArgs) { + ret = new MethodCallExpr(range(begin, token()), null, null, name, args); + } else { + ret = new NameExpr(name); + } + break; + } + default: + jj_la1[105] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } +return ret; +} + + final public Expression PrimarySuffix(Expression scope) throws ParseException {Expression ret; + if (jj_2_37(2)) { + ret = PrimarySuffixWithoutSuper(scope); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case DOT:{ + jj_consume_token(DOT); + jj_consume_token(SUPER); +ret = new SuperExpr(range(scope, token()), scope); + break; + } + default: + jj_la1[106] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return ret; +} + + final public Expression PrimarySuffixWithoutSuper(Expression scope) throws ParseException {Expression ret; + RangedList typeArgs = new RangedList(null); + NodeList args = emptyList(); + boolean hasArgs = false; + SimpleName name; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case DOT:{ + jj_consume_token(DOT); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case THIS:{ + jj_consume_token(THIS); +ret = new ThisExpr(range(scope, token()), scope); + break; + } + case NEW:{ + ret = AllocationExpression(scope); + break; + } + default: + jj_la1[109] = jj_gen; + if (jj_2_38(2147483647)) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typeArgs = TypeArguments(); + break; + } + default: + jj_la1[107] = jj_gen; + ; + } + name = SimpleName(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LPAREN:{ + args = Arguments(); +hasArgs=true; + break; + } + default: + jj_la1[108] = jj_gen; + ; + } +if (hasArgs) { + ret = new MethodCallExpr(range(scope, token()), scope, typeArgs.list, name, args); + } else { + ret = new FieldAccessExpr(range(scope, token()), scope, typeArgs.list, name); + } + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + break; + } + case LBRACKET:{ + jj_consume_token(LBRACKET); + ret = Expression(); + jj_consume_token(RBRACKET); +ret = new ArrayAccessExpr(range(scope, token()), scope, ret); + break; + } + default: + jj_la1[110] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return ret; +} + + final public Expression Literal() throws ParseException {Expression ret; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case INTEGER_LITERAL:{ + jj_consume_token(INTEGER_LITERAL); +ret = new IntegerLiteralExpr(tokenRange(), token.image); + break; + } + case LONG_LITERAL:{ + jj_consume_token(LONG_LITERAL); +ret = new LongLiteralExpr(tokenRange(), token.image); + break; + } + case FLOATING_POINT_LITERAL:{ + jj_consume_token(FLOATING_POINT_LITERAL); +ret = new DoubleLiteralExpr(tokenRange(), token.image); + break; + } + case CHARACTER_LITERAL:{ + jj_consume_token(CHARACTER_LITERAL); +ret = new CharLiteralExpr(tokenRange(), token.image.substring(1, token.image.length()-1)); + break; + } + case STRING_LITERAL:{ + jj_consume_token(STRING_LITERAL); +ret = new StringLiteralExpr(tokenRange(), token.image.substring(1, token.image.length()-1)); + break; + } + case FALSE: + case TRUE:{ + ret = BooleanLiteral(); + break; + } + case NULL:{ + ret = NullLiteral(); + break; + } + default: + jj_la1[111] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return ret; +} + + final public Expression BooleanLiteral() throws ParseException {Expression ret; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case TRUE:{ + jj_consume_token(TRUE); +ret = new BooleanLiteralExpr(tokenRange(), true); + break; + } + case FALSE:{ + jj_consume_token(FALSE); +ret = new BooleanLiteralExpr(tokenRange(), false); + break; + } + default: + jj_la1[112] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return ret; +} + + final public Expression NullLiteral() throws ParseException { + jj_consume_token(NULL); +return new NullLiteralExpr(tokenRange()); +} + + final public NodeList Arguments() throws ParseException {NodeList ret = emptyList(); + jj_consume_token(LPAREN); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + ret = ArgumentList(); + break; + } + default: + jj_la1[113] = jj_gen; + ; + } + jj_consume_token(RPAREN); +return ret; +} + + final public NodeList ArgumentList() throws ParseException {NodeList ret = emptyList(); + Expression expr; + expr = Expression(); +ret.add(expr); + label_41: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[114] = jj_gen; + break label_41; + } + jj_consume_token(COMMA); + expr = Expression(); +ret.add(expr); + } +return ret; +} + + final public Expression AllocationExpression(Expression scope) throws ParseException {Expression ret; + Type type; + RangedList typeArgs = new RangedList(null); + NodeList> anonymousBody = null; + NodeList args; + JavaToken begin = INVALID; + NodeList annotations = new NodeList(); + jj_consume_token(NEW); +if(scope==null) {begin=token();} else {begin = orIfInvalid(begin, scope);} + annotations = Annotations(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT:{ + type = PrimitiveType(annotations); + ret = ArrayCreation(begin, type); + break; + } + case ENUM: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case AT: + case LT:{ + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LT:{ + typeArgs = TypeArguments(); + break; + } + default: + jj_la1[115] = jj_gen; + ; + } + type = AnnotatedClassOrInterfaceType(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LBRACKET: + case AT:{ + ret = ArrayCreation(begin, type); + break; + } + case LPAREN:{ + args = Arguments(); + if (jj_2_39(2)) { + anonymousBody = ClassOrInterfaceBody(); + } else { + ; + } +ret = new ObjectCreationExpr(range(begin, token()), scope, (ClassOrInterfaceType) type, typeArgs.list, args, anonymousBody); + break; + } + default: + jj_la1[116] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + break; + } + default: + jj_la1[117] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return ret; +} + + final public ArrayCreationExpr ArrayCreation(JavaToken begin, Type type) throws ParseException {Expression expr = null; + ArrayInitializerExpr arrayInitializerExpr = null; + NodeList inits = emptyList(); + List> accum = new ArrayList>(); + NodeList annotations = new NodeList(); + JavaToken arrayCreationLevelStart = INVALID; + List levelRanges = new ArrayList(); + label_42: + while (true) { + annotations = Annotations(); + jj_consume_token(LBRACKET); +arrayCreationLevelStart = annotations.isEmpty() ? token() : orIfInvalid(arrayCreationLevelStart, annotations.get(0)); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + expr = Expression(); + break; + } + default: + jj_la1[118] = jj_gen; + ; + } +accum = add(accum, annotations); inits = add(inits, expr); annotations=null; expr=null; + jj_consume_token(RBRACKET); +levelRanges.add(range(arrayCreationLevelStart, token())); + if (jj_2_40(2)) { + ; + } else { + break label_42; + } + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LBRACE:{ + arrayInitializerExpr = ArrayInitializer(); + break; + } + default: + jj_la1[119] = jj_gen; + ; + } +return juggleArrayCreation(range(begin, token()), levelRanges, type, inits, accum, arrayInitializerExpr); +} + +/* + * Statement syntax follows. + */ + final public +Statement Statement() throws ParseException {Statement ret; + try { + if (jj_2_41(2)) { + ret = LabeledStatement(); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ASSERT:{ + ret = AssertStatement(); + break; + } + case LBRACE:{ + ret = Block(); + break; + } + case SEMICOLON:{ + ret = EmptyStatement(); + break; + } + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case INCR: + case DECR:{ + ret = StatementExpression(); + break; + } + case SWITCH:{ + ret = SwitchStatement(); + break; + } + case IF:{ + ret = IfStatement(); + break; + } + case WHILE:{ + ret = WhileStatement(); + break; + } + case DO:{ + ret = DoStatement(); + break; + } + case FOR:{ + ret = ForStatement(); + break; + } + case BREAK:{ + ret = BreakStatement(); + break; + } + case CONTINUE:{ + ret = ContinueStatement(); + break; + } + case RETURN:{ + ret = ReturnStatement(); + break; + } + case THROW:{ + ret = ThrowStatement(); + break; + } + case SYNCHRONIZED:{ + ret = SynchronizedStatement(); + break; + } + case TRY:{ + ret = TryStatement(); + break; + } + default: + jj_la1[120] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return ret; + } catch (ParseException e) { +TokenRange errorRange = recover(SEMICOLON, e); + return new UnparsableStmt(errorRange); + } +} + + final public AssertStmt AssertStatement() throws ParseException {Expression check; + Expression msg = null; + JavaToken begin; + jj_consume_token(ASSERT); +begin=token(); + check = Expression(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COLON:{ + jj_consume_token(COLON); + msg = Expression(); + break; + } + default: + jj_la1[121] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); +return new AssertStmt(range(begin, token()), check, msg); +} + + final public LabeledStmt LabeledStatement() throws ParseException {SimpleName label; + Statement stmt; + JavaToken begin; + label = SimpleName(); +begin=token(); + jj_consume_token(COLON); + stmt = Statement(); +return new LabeledStmt(range(begin, token()), label, stmt); +} + + final public BlockStmt Block() throws ParseException {NodeList stmts = emptyList(); + JavaToken begin; + jj_consume_token(LBRACE); +begin=token(); + try { + stmts = Statements(); + jj_consume_token(RBRACE); +return new BlockStmt(range(begin, token()), stmts); + } catch (ParseException e) { +recover(RBRACE, e); + BlockStmt block = new BlockStmt(range(begin, token()), new NodeList()); + block.setParsed(UNPARSABLE); + return block; + } +} + +/* + * Classes inside body statements can only be abstract or final. The semantic must check it. + */ + final public Statement BlockStatement() throws ParseException {Statement ret; + Expression expr; + ClassOrInterfaceDeclaration typeDecl; + ModifierHolder modifier; + try { + if (jj_2_42(2147483647)) { + modifier = Modifiers(); + typeDecl = ClassOrInterfaceDeclaration(modifier); +ret = new LocalClassDeclarationStmt(range(typeDecl, token()), typeDecl); + } else if (jj_2_43(2147483647)) { + expr = VariableDeclarationExpression(); + jj_consume_token(SEMICOLON); +ret = new ExpressionStmt(range(expr, token()), expr); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ASSERT: + case BOOLEAN: + case BREAK: + case BYTE: + case CHAR: + case CONTINUE: + case DO: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case FOR: + case IF: + case INT: + case LONG: + case NEW: + case NULL: + case RETURN: + case SHORT: + case STRICTFP: + case SUPER: + case SWITCH: + case SYNCHRONIZED: + case THIS: + case THROW: + case TRUE: + case TRY: + case VOID: + case WHILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case LBRACE: + case SEMICOLON: + case AT: + case INCR: + case DECR:{ + ret = Statement(); + break; + } + default: + jj_la1[122] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return ret; + } catch (ParseException e) { +TokenRange errorRange = recover(SEMICOLON, e); + return new UnparsableStmt(errorRange); + } +} + + final public VariableDeclarationExpr VariableDeclarationExpression() throws ParseException {ModifierHolder modifier; + Type partialType; + NodeList variables = new NodeList(); + VariableDeclarator var; + modifier = Modifiers(); + partialType = Type(emptyList()); + var = VariableDeclarator(partialType); +variables.add(var); + label_43: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[123] = jj_gen; + break label_43; + } + jj_consume_token(COMMA); + var = VariableDeclarator(partialType); +variables.add(var); + } +JavaToken begin=orIfInvalid(modifier.begin, partialType); + return new VariableDeclarationExpr(range(begin, token()), modifier.modifiers, modifier.annotations, variables); +} + + final public EmptyStmt EmptyStatement() throws ParseException { + jj_consume_token(SEMICOLON); +return new EmptyStmt(tokenRange()); +} + + final public Statement LambdaBody() throws ParseException {Expression expr; + Statement n = null; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + expr = Expression(); +n = new ExpressionStmt(range(expr, token()), expr); + break; + } + case LBRACE:{ + n = Block(); + break; + } + default: + jj_la1[124] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } +return n; +} + + final public ExpressionStmt StatementExpression() throws ParseException {Expression expr; + AssignExpr.Operator op; + Expression value; + RangedList typeArgs = new RangedList(null); + Statement lambdaBody; + if (jj_2_44(2)) { + expr = PreIncrementExpression(); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case DECR:{ + expr = PreDecrementExpression(); + break; + } + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT:{ + expr = PrimaryExpression(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ASSIGN: + case INCR: + case DECR: + case PLUSASSIGN: + case MINUSASSIGN: + case STARASSIGN: + case SLASHASSIGN: + case ANDASSIGN: + case ORASSIGN: + case XORASSIGN: + case REMASSIGN: + case LSHIFTASSIGN: + case RSIGNEDSHIFTASSIGN: + case RUNSIGNEDSHIFTASSIGN:{ + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case INCR:{ + jj_consume_token(INCR); +expr = new UnaryExpr(range(expr, token()), expr, UnaryExpr.Operator.POSTFIX_INCREMENT); + break; + } + case DECR:{ + jj_consume_token(DECR); +expr = new UnaryExpr(range(expr, token()), expr, UnaryExpr.Operator.POSTFIX_DECREMENT); + break; + } + case ASSIGN: + case PLUSASSIGN: + case MINUSASSIGN: + case STARASSIGN: + case SLASHASSIGN: + case ANDASSIGN: + case ORASSIGN: + case XORASSIGN: + case REMASSIGN: + case LSHIFTASSIGN: + case RSIGNEDSHIFTASSIGN: + case RUNSIGNEDSHIFTASSIGN:{ + op = AssignmentOperator(); + value = Expression(); +expr = new AssignExpr(range(expr, token()), expr, value, op); + break; + } + default: + jj_la1[125] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + break; + } + default: + jj_la1[126] = jj_gen; + ; + } + break; + } + default: + jj_la1[127] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + jj_consume_token(SEMICOLON); +return new ExpressionStmt(range(expr, token()), expr); +} + + final public SwitchStmt SwitchStatement() throws ParseException {Expression selector; + SwitchEntryStmt entry; + NodeList entries = emptyList(); + JavaToken begin; + jj_consume_token(SWITCH); +begin=token(); + jj_consume_token(LPAREN); + selector = Expression(); + jj_consume_token(RPAREN); + jj_consume_token(LBRACE); + label_44: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case CASE: + case _DEFAULT:{ + ; + break; + } + default: + jj_la1[128] = jj_gen; + break label_44; + } + entry = SwitchEntry(); +entries = add(entries, entry); + } + jj_consume_token(RBRACE); +return new SwitchStmt(range(begin, token()), selector, entries); +} + + final public SwitchEntryStmt SwitchEntry() throws ParseException {Expression label = null; + NodeList stmts; + JavaToken begin; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case CASE:{ + jj_consume_token(CASE); +begin=token(); + label = Expression(); + break; + } + case _DEFAULT:{ + jj_consume_token(_DEFAULT); +begin=token(); + break; + } + default: + jj_la1[129] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(COLON); + stmts = Statements(); +return new SwitchEntryStmt(range(begin, token()),label, stmts); +} + + final public IfStmt IfStatement() throws ParseException {Expression condition; + Statement thenStmt; + Statement elseStmt = null; + JavaToken begin; + jj_consume_token(IF); +begin=token(); + jj_consume_token(LPAREN); + condition = Expression(); + jj_consume_token(RPAREN); + + thenStmt = Statement(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ELSE:{ + jj_consume_token(ELSE); + + elseStmt = Statement(); + break; + } + default: + jj_la1[130] = jj_gen; + ; + } +return new IfStmt(range(begin, token()), condition, thenStmt, elseStmt); +} + + final public WhileStmt WhileStatement() throws ParseException {Expression condition; + Statement body; + JavaToken begin; + jj_consume_token(WHILE); +begin=token(); + jj_consume_token(LPAREN); + condition = Expression(); + jj_consume_token(RPAREN); + body = Statement(); +return new WhileStmt(range(begin, token()),condition, body); +} + + final public DoStmt DoStatement() throws ParseException {Expression condition; + Statement body; + JavaToken begin; + jj_consume_token(DO); +begin=token(); + body = Statement(); + jj_consume_token(WHILE); + jj_consume_token(LPAREN); + condition = Expression(); + jj_consume_token(RPAREN); + jj_consume_token(SEMICOLON); +return new DoStmt(range(begin, token()),body, condition); +} + + final public Statement ForStatement() throws ParseException {VariableDeclarationExpr varExpr = null; + Expression expr = null; + NodeList init = emptyList(); + NodeList update = emptyList(); + Statement body; + JavaToken begin; + jj_consume_token(FOR); +begin=token(); + jj_consume_token(LPAREN); + if (jj_2_45(2147483647)) { + varExpr = VariableDeclarationExpression(); + jj_consume_token(COLON); + expr = Expression(); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FALSE: + case FINAL: + case FLOAT: + case INT: + case LONG: + case NATIVE: + case NEW: + case NULL: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SUPER: + case SYNCHRONIZED: + case THIS: + case TRANSIENT: + case TRUE: + case VOID: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case SEMICOLON: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FALSE: + case FINAL: + case FLOAT: + case INT: + case LONG: + case NATIVE: + case NEW: + case NULL: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SUPER: + case SYNCHRONIZED: + case THIS: + case TRANSIENT: + case TRUE: + case VOID: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + init = ForInit(); + break; + } + default: + jj_la1[131] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + expr = Expression(); + break; + } + default: + jj_la1[132] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + update = ForUpdate(); + break; + } + default: + jj_la1[133] = jj_gen; + ; + } + break; + } + default: + jj_la1[134] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + jj_consume_token(RPAREN); + body = Statement(); +if (varExpr != null) { + return new ForeachStmt(range(begin, token()),varExpr, expr, body); + } + return new ForStmt(range(begin, token()),init, expr, update, body); +} + + final public NodeList ForInit() throws ParseException {NodeList ret; + Expression expr; + if (jj_2_46(2147483647)) { + expr = VariableDeclarationExpression(); +ret = new NodeList(); ret.add(expr); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + ret = ExpressionList(); + break; + } + default: + jj_la1[135] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return ret; +} + + final public NodeList ExpressionList() throws ParseException {NodeList ret = new NodeList(); + Expression expr; + expr = Expression(); +ret.add(expr); + label_45: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[136] = jj_gen; + break label_45; + } + jj_consume_token(COMMA); + expr = Expression(); +ret.add(expr); + } +return ret; +} + + final public NodeList ForUpdate() throws ParseException {NodeList ret; + ret = ExpressionList(); +return ret; +} + + final public BreakStmt BreakStatement() throws ParseException {SimpleName label = null; + JavaToken begin; + jj_consume_token(BREAK); +begin=token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ENUM: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + label = SimpleName(); + break; + } + default: + jj_la1[137] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); +return new BreakStmt(range(begin, token()), label); +} + + final public ContinueStmt ContinueStatement() throws ParseException {SimpleName label = null; + JavaToken begin; + jj_consume_token(CONTINUE); +begin=token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ENUM: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + label = SimpleName(); + break; + } + default: + jj_la1[138] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); +return new ContinueStmt(range(begin, token()), label); +} + + final public ReturnStmt ReturnStatement() throws ParseException {Expression expr = null; + JavaToken begin; + jj_consume_token(RETURN); +begin=token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + expr = Expression(); + break; + } + default: + jj_la1[139] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); +return new ReturnStmt(range(begin, token()),expr); +} + + final public ThrowStmt ThrowStatement() throws ParseException {Expression expr; + JavaToken begin; + jj_consume_token(THROW); +begin=token(); + expr = Expression(); + jj_consume_token(SEMICOLON); +return new ThrowStmt(range(begin, token()),expr); +} + + final public SynchronizedStmt SynchronizedStatement() throws ParseException {Expression expr; + BlockStmt body; + JavaToken begin; + jj_consume_token(SYNCHRONIZED); +begin=token(); + jj_consume_token(LPAREN); + expr = Expression(); + jj_consume_token(RPAREN); + body = Block(); +return new SynchronizedStmt(range(begin, token()),expr, body); +} + + final public TryStmt TryStatement() throws ParseException {NodeList resources = emptyList(); + BlockStmt tryBlock; + BlockStmt finallyBlock = null; + NodeList catchs = emptyList(); + BlockStmt catchBlock; + ModifierHolder exceptModifier; + ReferenceType exceptionType; + NodeList exceptionTypes = emptyList(); + Pair> exceptId; + JavaToken begin; + JavaToken catchBegin; + JavaToken typesBegin; + JavaToken paramEnd; + Type type; + jj_consume_token(TRY); +begin=token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LPAREN:{ + resources = ResourceSpecification(); + break; + } + default: + jj_la1[140] = jj_gen; + ; + } + tryBlock = Block(); + label_46: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case CATCH:{ + ; + break; + } + default: + jj_la1[141] = jj_gen; + break label_46; + } + jj_consume_token(CATCH); +catchBegin=token(); + jj_consume_token(LPAREN); +typesBegin=token(); + exceptModifier = Modifiers(); + exceptionType = ReferenceType(emptyList()); +exceptionTypes.add(exceptionType); + label_47: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BIT_OR:{ + ; + break; + } + default: + jj_la1[142] = jj_gen; + break label_47; + } + jj_consume_token(BIT_OR); + exceptionType = AnnotatedReferenceType(); +exceptionTypes.add(exceptionType); + } + exceptId = VariableDeclaratorId(); +paramEnd = token(); + jj_consume_token(RPAREN); + catchBlock = Block(); +if (exceptionTypes.size() > 1) { + type = new UnionType(range(exceptionTypes.get(0), exceptionTypes.get(exceptionTypes.size() - 1)), exceptionTypes); + } else { + type = (Type)exceptionTypes.get(0); + } + Parameter catchType = new Parameter(range(type, paramEnd), exceptModifier.modifiers, exceptModifier.annotations, type, false, emptyList(), exceptId.a); + catchs = add(catchs, new CatchClause(range(catchBegin, token()), catchType, catchBlock)); + exceptionTypes = emptyList(); + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case FINALLY:{ + jj_consume_token(FINALLY); + finallyBlock = Block(); + break; + } + default: + jj_la1[143] = jj_gen; + ; + } +return new TryStmt(range(begin, token()), resources, tryBlock, catchs, finallyBlock); +} + + final public NodeList ResourceSpecification() throws ParseException {NodeList variables; + jj_consume_token(LPAREN); + variables = Resources(); + if (jj_2_47(2)) { + jj_consume_token(SEMICOLON); + } else { + ; + } + jj_consume_token(RPAREN); +return variables; +} + + final public NodeList Resources() throws ParseException {NodeList expressions = new NodeList(); + Expression expr; + expr = Resource(); +expressions.add(expr); + label_48: + while (true) { + if (jj_2_48(2)) { + ; + } else { + break label_48; + } + jj_consume_token(SEMICOLON); + expr = Resource(); +expressions.add(expr); + } +return expressions; +} + + final public Expression Resource() throws ParseException {Expression expr; + if (jj_2_49(2147483647)) { + /*this is a bit more lenient than we need to be, eg allowing access modifiers like private*/ + expr = VariableDeclarationExpression(); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT:{ + expr = PrimaryExpression(); + break; + } + default: + jj_la1[144] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return expr; +} + +/* We use productions to match >>>, >> and > so that we can keep the + * type declaration syntax with generics clean + */ + final public +void RUNSIGNEDSHIFT() throws ParseException { + if (getToken(1).kind == GT && + getToken(1).realKind == RUNSIGNEDSHIFT) { + + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(GT); + jj_consume_token(GT); + jj_consume_token(GT); +} + + final public void RSIGNEDSHIFT() throws ParseException { + if (getToken(1).kind == GT && + getToken(1).realKind == RSIGNEDSHIFT) { + + } else { + jj_consume_token(-1); + throw new ParseException(); + } + jj_consume_token(GT); + jj_consume_token(GT); +} + +/* Annotation syntax follows. */ + final public +NodeList Annotations() throws ParseException {NodeList annotations = new NodeList(); + AnnotationExpr annotation; + label_49: + while (true) { + if (jj_2_50(2147483647)) { + ; + } else { + break label_49; + } + annotation = Annotation(); +annotations = add(annotations, annotation); + } +return annotations; +} + + final public AnnotationExpr Annotation() throws ParseException {AnnotationExpr ret; + Name name; + NodeList pairs = emptyList(); + JavaToken begin; + Expression memberVal; + jj_consume_token(AT); +begin=token(); + name = Name(); + if (jj_2_51(2147483647)) { + jj_consume_token(LPAREN); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ENUM: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + pairs = MemberValuePairs(); + break; + } + default: + jj_la1[145] = jj_gen; + ; + } + jj_consume_token(RPAREN); +ret = new NormalAnnotationExpr(range(begin, token()), name, pairs); + } else if (jj_2_52(2147483647)) { + jj_consume_token(LPAREN); + memberVal = MemberValue(); + jj_consume_token(RPAREN); +ret = new SingleMemberAnnotationExpr(range(begin, token()), name, memberVal); + } else { +ret = new MarkerAnnotationExpr(range(begin, token()), name); + } +return ret; +} + + final public NodeList MemberValuePairs() throws ParseException {NodeList ret = new NodeList(); + MemberValuePair pair; + pair = MemberValuePair(); +ret.add(pair); + label_50: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[146] = jj_gen; + break label_50; + } + jj_consume_token(COMMA); + pair = MemberValuePair(); +ret.add(pair); + } +return ret; +} + + final public MemberValuePair MemberValuePair() throws ParseException {SimpleName name; + Expression value; + JavaToken begin; + name = SimpleName(); +begin=token(); + jj_consume_token(ASSIGN); + value = MemberValue(); +return new MemberValuePair(range(begin, token()),name, value); +} + + final public Expression MemberValue() throws ParseException {Expression ret; + if (jj_2_53(2147483647)) { + ret = Annotation(); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case LBRACE:{ + ret = MemberValueArrayInitializer(); + break; + } + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + ret = ConditionalExpression(); + break; + } + default: + jj_la1[147] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return ret; +} + + final public Expression MemberValueArrayInitializer() throws ParseException {NodeList ret = emptyList(); + Expression member; + JavaToken begin; + jj_consume_token(LBRACE); +begin=token(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case LBRACE: + case AT: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS:{ + member = MemberValue(); +ret.add(member); + label_51: + while (true) { + if (jj_2_54(2)) { + ; + } else { + break label_51; + } + jj_consume_token(COMMA); + member = MemberValue(); +ret.add(member); + } + break; + } + default: + jj_la1[148] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + jj_consume_token(COMMA); + break; + } + default: + jj_la1[149] = jj_gen; + ; + } + jj_consume_token(RBRACE); +return new ArrayInitializerExpr(range(begin, token()),ret); +} + +/* Annotation Types. */ + final public +AnnotationDeclaration AnnotationTypeDeclaration(ModifierHolder modifier) throws ParseException {SimpleName name; + NodeList> members = emptyList(); + JavaToken begin = modifier.begin; + jj_consume_token(AT); +begin=orIfInvalid(begin, token()); + jj_consume_token(INTERFACE); + name = SimpleName(); + members = AnnotationTypeBody(); +return new AnnotationDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, name, members); +} + + final public NodeList> AnnotationTypeBody() throws ParseException {NodeList> ret = emptyList(); + BodyDeclaration member; + jj_consume_token(LBRACE); + label_52: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case CLASS: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case INTERFACE: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case SEMICOLON: + case AT:{ + ; + break; + } + default: + jj_la1[150] = jj_gen; + break label_52; + } + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case CLASS: + case _DEFAULT: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case INTERFACE: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOLATILE: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER: + case AT:{ + member = AnnotationBodyDeclaration(); +ret = addWhenNotNull(ret, member); + break; + } + case SEMICOLON:{ + jj_consume_token(SEMICOLON); + break; + } + default: + jj_la1[151] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + jj_consume_token(RBRACE); +return ret; +} + + final public BodyDeclaration AnnotationBodyDeclaration() throws ParseException {ModifierHolder modifier; + BodyDeclaration ret; + modifier = Modifiers(); + if (jj_2_55(2147483647)) { + ret = AnnotationTypeMemberDeclaration(modifier); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case CLASS: + case INTERFACE:{ + ret = ClassOrInterfaceDeclaration(modifier); + break; + } + default: + jj_la1[152] = jj_gen; + if (jj_2_56(2147483647)) { + ret = EnumDeclaration(modifier); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case AT:{ + ret = AnnotationTypeDeclaration(modifier); + break; + } + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FLOAT: + case INT: + case LONG: + case SHORT: + case STRICTFP: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case IDENTIFIER:{ + ret = FieldDeclaration(modifier); + break; + } + default: + jj_la1[153] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } + } +return ret; +} + + final public AnnotationMemberDeclaration AnnotationTypeMemberDeclaration(ModifierHolder modifier) throws ParseException {Type type; + SimpleName name; + Expression defaultVal = null; + type = Type(emptyList()); + name = SimpleName(); + jj_consume_token(LPAREN); + jj_consume_token(RPAREN); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case _DEFAULT:{ + defaultVal = DefaultValue(); + break; + } + default: + jj_la1[154] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); +JavaToken begin = orIfInvalid(modifier.begin, type); + return new AnnotationMemberDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, type, name, defaultVal); +} + + final public Expression DefaultValue() throws ParseException {Expression ret; + jj_consume_token(_DEFAULT); + ret = MemberValue(); +return ret; +} + +/* Module syntax follows */ + final public + +ModuleStmt ModuleStmt() throws ParseException {ModifierHolder modifiers; + Name name; + Name tmpName; + NodeList names=emptyList(); + Type type; + Type tmpType; + NodeList types=emptyList(); + JavaToken begin; + ModuleStmt stmt=new ModuleRequiresStmt(); + JavaToken transitiveExceptionalToken; + if (jj_2_57(2147483647)) { + jj_consume_token(REQUIRES); +begin=token(); + jj_consume_token(TRANSITIVE); +transitiveExceptionalToken=token(); setTokenKind(IDENTIFIER); + jj_consume_token(SEMICOLON); +stmt=new ModuleRequiresStmt(range(begin, token()), EnumSet.noneOf(Modifier.class), new Name(range(transitiveExceptionalToken, transitiveExceptionalToken), null, transitiveExceptionalToken.getText(), new NodeList())); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case REQUIRES:{ + jj_consume_token(REQUIRES); +begin=token(); + modifiers = Modifiers(); + name = Name(); + jj_consume_token(SEMICOLON); +stmt=new ModuleRequiresStmt(range(begin, token()), modifiers.modifiers, name); + break; + } + case EXPORTS:{ + jj_consume_token(EXPORTS); +begin=token(); + name = Name(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case TO:{ + jj_consume_token(TO); + tmpName = Name(); +names.add(tmpName); + label_53: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[155] = jj_gen; + break label_53; + } + jj_consume_token(COMMA); + tmpName = Name(); +names.add(tmpName); + } + break; + } + default: + jj_la1[156] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); +stmt=new ModuleExportsStmt(range(begin, token()), name, names); + break; + } + case OPENS:{ + jj_consume_token(OPENS); +begin=token(); + name = Name(); + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case TO:{ + jj_consume_token(TO); + tmpName = Name(); +names.add(tmpName); + label_54: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[157] = jj_gen; + break label_54; + } + jj_consume_token(COMMA); + tmpName = Name(); +names.add(tmpName); + } + break; + } + default: + jj_la1[158] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); +stmt=new ModuleOpensStmt(range(begin, token()), name, names); + break; + } + case USES:{ + jj_consume_token(USES); +begin=token(); + type = Type(emptyList()); + jj_consume_token(SEMICOLON); +stmt=new ModuleUsesStmt(range(begin, token()), type); + break; + } + case PROVIDES:{ + jj_consume_token(PROVIDES); +begin=token(); + type = Type(emptyList()); + jj_consume_token(WITH); + tmpType = Type(emptyList()); +types.add(tmpType); + label_55: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case COMMA:{ + ; + break; + } + default: + jj_la1[159] = jj_gen; + break label_55; + } + jj_consume_token(COMMA); + tmpType = Type(emptyList()); +types.add(tmpType); + } + jj_consume_token(SEMICOLON); +stmt=new ModuleProvidesStmt(range(begin, token()), type, types); + break; + } + default: + jj_la1[160] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } +return stmt; +} + + final public ModuleDeclaration ModuleDeclaration(ModifierHolder modifier) throws ParseException {NodeList statements = new NodeList(); + boolean open=false; + ModuleStmt st; + Name name; + JavaToken begin = modifier.begin; + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case OPEN:{ + jj_consume_token(OPEN); +open=true; begin = orIfInvalid(begin, token()); + break; + } + default: + jj_la1[161] = jj_gen; + ; + } + jj_consume_token(MODULE); +begin = orIfInvalid(begin, token()); + name = Name(); + jj_consume_token(LBRACE); + label_56: + while (true) { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case REQUIRES: + case OPENS: + case USES: + case EXPORTS: + case PROVIDES:{ + ; + break; + } + default: + jj_la1[162] = jj_gen; + break label_56; + } + st = ModuleStmt(); +statements = add(statements, st); + } + jj_consume_token(RBRACE); +return new ModuleDeclaration(range(begin, token()), modifier.annotations, name, open, statements); +} + +/* Rules for matching partial inputs. +These rules are needed to properly terminate them - +if we simply use the usual rules, they will ignore everything in the provider +after they matched their desired input, which will lead to unexpected behaviour +*/ + final public + +BlockStmt BlockParseStart() throws ParseException {BlockStmt ret; + ret = Block(); + jj_consume_token(0); +return ret; +} + + final public Statement BlockStatementParseStart() throws ParseException {Statement ret; + if (jj_2_58(3)) { + ret = BlockStatement(); + } else { + switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case ENUM: + case FALSE: + case FLOAT: + case INT: + case LONG: + case NEW: + case NULL: + case SHORT: + case STRICTFP: + case SUPER: + case THIS: + case TRUE: + case VOID: + case REQUIRES: + case TO: + case WITH: + case OPEN: + case OPENS: + case USES: + case MODULE: + case EXPORTS: + case PROVIDES: + case TRANSITIVE: + case LONG_LITERAL: + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + case AT: + case LT:{ + ret = ExplicitConstructorInvocation(); + break; + } + default: + jj_la1[163] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + jj_consume_token(0); +return ret; +} + + final public ImportDeclaration ImportDeclarationParseStart() throws ParseException {ImportDeclaration ret; + ret = ImportDeclaration(); + jj_consume_token(0); +return ret; +} + + final public Expression ExpressionParseStart() throws ParseException {Expression ret; + ret = Expression(); + jj_consume_token(0); +return ret; +} + + final public AnnotationExpr AnnotationParseStart() throws ParseException {AnnotationExpr ret; + ret = Annotation(); + jj_consume_token(0); +return ret; +} + + final public BodyDeclaration AnnotationBodyDeclarationParseStart() throws ParseException {BodyDeclaration ret; + ret = AnnotationBodyDeclaration(); + jj_consume_token(0); +return ret; +} + + final public BodyDeclaration ClassOrInterfaceBodyDeclarationParseStart() throws ParseException {BodyDeclaration ret; + ret = ClassOrInterfaceBodyDeclaration(); + jj_consume_token(0); +return ret; +} + + final public ClassOrInterfaceType ClassOrInterfaceTypeParseStart() throws ParseException {ClassOrInterfaceType ret; + ret = AnnotatedClassOrInterfaceType(); + jj_consume_token(0); +return ret; +} + + final public Type ResultTypeParseStart() throws ParseException {NodeList annotations; Type ret; + annotations = Annotations(); + ret = ResultType(annotations); + jj_consume_token(0); +return ret; +} + + final public VariableDeclarationExpr VariableDeclarationExpressionParseStart() throws ParseException {VariableDeclarationExpr ret; + ret = VariableDeclarationExpression(); + jj_consume_token(0); +return ret; +} + + final public ExplicitConstructorInvocationStmt ExplicitConstructorInvocationParseStart() throws ParseException {ExplicitConstructorInvocationStmt ret; + ret = ExplicitConstructorInvocation(); + jj_consume_token(0); +return ret; +} + + final public Name NameParseStart() throws ParseException {Name ret; + ret = Name(); + jj_consume_token(0); +return ret; +} + + final public SimpleName SimpleNameParseStart() throws ParseException {SimpleName ret; + ret = SimpleName(); + jj_consume_token(0); +return ret; +} + + final public Parameter ParameterParseStart() throws ParseException {Parameter ret; + ret = Parameter(); + jj_consume_token(0); +return ret; +} + + final public PackageDeclaration PackageDeclarationParseStart() throws ParseException {PackageDeclaration ret; + ret = PackageDeclaration(); + jj_consume_token(0); +return ret; +} + + private boolean jj_2_1(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_1()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(0, xla); } + } + + private boolean jj_2_2(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_2()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1, xla); } + } + + private boolean jj_2_3(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_3()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(2, xla); } + } + + private boolean jj_2_4(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_4()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(3, xla); } + } + + private boolean jj_2_5(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_5()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(4, xla); } + } + + private boolean jj_2_6(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_6()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(5, xla); } + } + + private boolean jj_2_7(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_7()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(6, xla); } + } + + private boolean jj_2_8(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_8()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(7, xla); } + } + + private boolean jj_2_9(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_9()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(8, xla); } + } + + private boolean jj_2_10(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_10()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(9, xla); } + } + + private boolean jj_2_11(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_11()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(10, xla); } + } + + private boolean jj_2_12(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_12()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(11, xla); } + } + + private boolean jj_2_13(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_13()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(12, xla); } + } + + private boolean jj_2_14(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_14()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(13, xla); } + } + + private boolean jj_2_15(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_15()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(14, xla); } + } + + private boolean jj_2_16(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_16()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(15, xla); } + } + + private boolean jj_2_17(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_17()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(16, xla); } + } + + private boolean jj_2_18(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_18()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(17, xla); } + } + + private boolean jj_2_19(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_19()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(18, xla); } + } + + private boolean jj_2_20(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_20()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(19, xla); } + } + + private boolean jj_2_21(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_21()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(20, xla); } + } + + private boolean jj_2_22(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_22()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(21, xla); } + } + + private boolean jj_2_23(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_23()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(22, xla); } + } + + private boolean jj_2_24(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_24()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(23, xla); } + } + + private boolean jj_2_25(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_25()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(24, xla); } + } + + private boolean jj_2_26(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_26()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(25, xla); } + } + + private boolean jj_2_27(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_27()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(26, xla); } + } + + private boolean jj_2_28(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_28()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(27, xla); } + } + + private boolean jj_2_29(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_29()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(28, xla); } + } + + private boolean jj_2_30(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_30()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(29, xla); } + } + + private boolean jj_2_31(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_31()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(30, xla); } + } + + private boolean jj_2_32(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_32()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(31, xla); } + } + + private boolean jj_2_33(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_33()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(32, xla); } + } + + private boolean jj_2_34(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_34()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(33, xla); } + } + + private boolean jj_2_35(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_35()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(34, xla); } + } + + private boolean jj_2_36(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_36()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(35, xla); } + } + + private boolean jj_2_37(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_37()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(36, xla); } + } + + private boolean jj_2_38(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_38()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(37, xla); } + } + + private boolean jj_2_39(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_39()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(38, xla); } + } + + private boolean jj_2_40(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_40()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(39, xla); } + } + + private boolean jj_2_41(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_41()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(40, xla); } + } + + private boolean jj_2_42(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_42()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(41, xla); } + } + + private boolean jj_2_43(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_43()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(42, xla); } + } + + private boolean jj_2_44(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_44()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(43, xla); } + } + + private boolean jj_2_45(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_45()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(44, xla); } + } + + private boolean jj_2_46(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_46()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(45, xla); } + } + + private boolean jj_2_47(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_47()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(46, xla); } + } + + private boolean jj_2_48(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_48()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(47, xla); } + } + + private boolean jj_2_49(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_49()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(48, xla); } + } + + private boolean jj_2_50(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_50()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(49, xla); } + } + + private boolean jj_2_51(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_51()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(50, xla); } + } + + private boolean jj_2_52(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_52()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(51, xla); } + } + + private boolean jj_2_53(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_53()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(52, xla); } + } + + private boolean jj_2_54(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_54()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(53, xla); } + } + + private boolean jj_2_55(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_55()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(54, xla); } + } + + private boolean jj_2_56(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_56()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(55, xla); } + } + + private boolean jj_2_57(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_57()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(56, xla); } + } + + private boolean jj_2_58(int xla) + { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return (!jj_3_58()); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(57, xla); } + } + + private boolean jj_3R_304() + { + if (jj_scan_token(EXTENDS)) return true; + if (jj_3R_306()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_408()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_296() + { + if (jj_3R_324()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_364()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_227() + { + if (jj_scan_token(INTERFACE)) return true; + return false; + } + + private boolean jj_3R_262() + { + if (jj_3R_305()) return true; + return false; + } + + private boolean jj_3R_286() + { + if (jj_scan_token(DO)) return true; + if (jj_3R_195()) return true; + if (jj_scan_token(WHILE)) return true; + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_90()) return true; + if (jj_scan_token(RPAREN)) return true; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_261() + { + if (jj_3R_304()) return true; + return false; + } + + private boolean jj_3R_260() + { + if (jj_3R_117()) return true; + return false; + } + + private boolean jj_3R_248() + { + if (jj_3R_296()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_348()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_194() + { + Token xsp; + xsp = jj_scanpos; + if (jj_scan_token(19)) { + jj_scanpos = xsp; + if (jj_3R_227()) return true; + } + if (jj_3R_88()) return true; + xsp = jj_scanpos; + if (jj_3R_260()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_261()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_262()) jj_scanpos = xsp; + if (jj_3R_105()) return true; + return false; + } + + private boolean jj_3R_169() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_112()) return true; + return false; + } + + private boolean jj_3R_285() + { + if (jj_scan_token(WHILE)) return true; + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_90()) return true; + if (jj_scan_token(RPAREN)) return true; + if (jj_3R_195()) return true; + return false; + } + + private boolean jj_3R_328() + { + if (jj_3R_74()) return true; + return false; + } + + private boolean jj_3R_200() + { + if (jj_3R_248()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_325()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_300() + { + if (jj_scan_token(HOOK)) return true; + if (jj_3R_90()) return true; + if (jj_scan_token(COLON)) return true; + if (jj_3R_149()) return true; + return false; + } + + private boolean jj_3R_149() + { + if (jj_3R_200()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_300()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_284() + { + if (jj_scan_token(IF)) return true; + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_90()) return true; + if (jj_scan_token(RPAREN)) return true; + if (jj_3R_195()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_411()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_71() + { + if (jj_3R_115()) return true; + return false; + } + + private boolean jj_3R_70() + { + if (jj_scan_token(_DEFAULT)) return true; + return false; + } + + private boolean jj_3R_69() + { + if (jj_scan_token(TRANSITIVE)) return true; + return false; + } + + private boolean jj_3R_148() + { + if (jj_scan_token(ORASSIGN)) return true; + return false; + } + + private boolean jj_3R_147() + { + if (jj_scan_token(XORASSIGN)) return true; + return false; + } + + private boolean jj_3R_68() + { + if (jj_scan_token(STRICTFP)) return true; + return false; + } + + private boolean jj_3R_146() + { + if (jj_scan_token(ANDASSIGN)) return true; + return false; + } + + private boolean jj_3R_145() + { + if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true; + return false; + } + + private boolean jj_3R_431() + { + if (jj_scan_token(_DEFAULT)) return true; + return false; + } + + private boolean jj_3R_67() + { + if (jj_scan_token(VOLATILE)) return true; + return false; + } + + private boolean jj_3R_144() + { + if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true; + return false; + } + + private boolean jj_3R_143() + { + if (jj_scan_token(LSHIFTASSIGN)) return true; + return false; + } + + private boolean jj_3R_430() + { + if (jj_scan_token(CASE)) return true; + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_66() + { + if (jj_scan_token(TRANSIENT)) return true; + return false; + } + + private boolean jj_3R_142() + { + if (jj_scan_token(MINUSASSIGN)) return true; + return false; + } + + private boolean jj_3R_141() + { + if (jj_scan_token(PLUSASSIGN)) return true; + return false; + } + + private boolean jj_3R_65() + { + if (jj_scan_token(NATIVE)) return true; + return false; + } + + private boolean jj_3R_140() + { + if (jj_scan_token(REMASSIGN)) return true; + return false; + } + + private boolean jj_3R_139() + { + if (jj_scan_token(SLASHASSIGN)) return true; + return false; + } + + private boolean jj_3R_64() + { + if (jj_scan_token(SYNCHRONIZED)) return true; + return false; + } + + private boolean jj_3R_138() + { + if (jj_scan_token(STARASSIGN)) return true; + return false; + } + + private boolean jj_3R_327() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3R_137() + { + if (jj_scan_token(ASSIGN)) return true; + return false; + } + + private boolean jj_3R_63() + { + if (jj_scan_token(ABSTRACT)) return true; + return false; + } + + private boolean jj_3R_62() + { + if (jj_scan_token(FINAL)) return true; + return false; + } + + private boolean jj_3R_424() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_430()) { + jj_scanpos = xsp; + if (jj_3R_431()) return true; + } + if (jj_scan_token(COLON)) return true; + if (jj_3R_179()) return true; + return false; + } + + private boolean jj_3R_61() + { + if (jj_scan_token(PRIVATE)) return true; + return false; + } + + private boolean jj_3R_89() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_137()) { + jj_scanpos = xsp; + if (jj_3R_138()) { + jj_scanpos = xsp; + if (jj_3R_139()) { + jj_scanpos = xsp; + if (jj_3R_140()) { + jj_scanpos = xsp; + if (jj_3R_141()) { + jj_scanpos = xsp; + if (jj_3R_142()) { + jj_scanpos = xsp; + if (jj_3R_143()) { + jj_scanpos = xsp; + if (jj_3R_144()) { + jj_scanpos = xsp; + if (jj_3R_145()) { + jj_scanpos = xsp; + if (jj_3R_146()) { + jj_scanpos = xsp; + if (jj_3R_147()) { + jj_scanpos = xsp; + if (jj_3R_148()) return true; + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + private boolean jj_3R_302() + { + if (jj_scan_token(DOUBLECOLON)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_327()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_328()) { + jj_scanpos = xsp; + if (jj_scan_token(42)) return true; + } + return false; + } + + private boolean jj_3R_60() + { + if (jj_scan_token(PROTECTED)) return true; + return false; + } + + private boolean jj_3R_59() + { + if (jj_scan_token(STATIC)) return true; + return false; + } + + private boolean jj_3R_58() + { + if (jj_scan_token(PUBLIC)) return true; + return false; + } + + private boolean jj_3R_410() + { + if (jj_3R_424()) return true; + return false; + } + + private boolean jj_3_3() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_58()) { + jj_scanpos = xsp; + if (jj_3R_59()) { + jj_scanpos = xsp; + if (jj_3R_60()) { + jj_scanpos = xsp; + if (jj_3R_61()) { + jj_scanpos = xsp; + if (jj_3R_62()) { + jj_scanpos = xsp; + if (jj_3R_63()) { + jj_scanpos = xsp; + if (jj_3R_64()) { + jj_scanpos = xsp; + if (jj_3R_65()) { + jj_scanpos = xsp; + if (jj_3R_66()) { + jj_scanpos = xsp; + if (jj_3R_67()) { + jj_scanpos = xsp; + if (jj_3R_68()) { + jj_scanpos = xsp; + if (jj_3R_69()) { + jj_scanpos = xsp; + if (jj_3R_70()) { + jj_scanpos = xsp; + if (jj_3R_71()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + private boolean jj_3R_108() + { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_3()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_283() + { + if (jj_scan_token(SWITCH)) return true; + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_90()) return true; + if (jj_scan_token(RPAREN)) return true; + if (jj_scan_token(LBRACE)) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_410()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(RBRACE)) return true; + return false; + } + + private boolean jj_3R_301() + { + if (jj_scan_token(ARROW)) return true; + if (jj_3R_326()) return true; + return false; + } + + private boolean jj_3R_361() + { + if (jj_3R_89()) return true; + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_360() + { + if (jj_scan_token(DECR)) return true; + return false; + } + + private boolean jj_3_24() + { + if (jj_3R_89()) return true; + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_359() + { + if (jj_scan_token(INCR)) return true; + return false; + } + + private boolean jj_3R_343() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_359()) { + jj_scanpos = xsp; + if (jj_3R_360()) { + jj_scanpos = xsp; + if (jj_3R_361()) return true; + } + } + return false; + } + + private boolean jj_3R_255() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3_24()) { + jj_scanpos = xsp; + if (jj_3R_301()) { + jj_scanpos = xsp; + if (jj_3R_302()) return true; + } + } + return false; + } + + private boolean jj_3R_318() + { + if (jj_3R_211()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_343()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_90() + { + if (jj_3R_149()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_255()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_317() + { + if (jj_3R_257()) return true; + return false; + } + + private boolean jj_3_44() + { + if (jj_3R_110()) return true; + return false; + } + + private boolean jj_3R_282() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3_44()) { + jj_scanpos = xsp; + if (jj_3R_317()) { + jj_scanpos = xsp; + if (jj_3R_318()) return true; + } + } + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_57() + { + if (jj_3R_86()) return true; + if (jj_scan_token(PACKAGE)) return true; + if (jj_3R_80()) return true; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_350() + { + if (jj_3R_121()) return true; + return false; + } + + private boolean jj_3R_349() + { + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_74() + { + Token xsp; + xsp = jj_scanpos; + if (jj_scan_token(70)) { + jj_scanpos = xsp; + if (jj_scan_token(64)) { + jj_scanpos = xsp; + if (jj_scan_token(65)) { + jj_scanpos = xsp; + if (jj_scan_token(66)) { + jj_scanpos = xsp; + if (jj_scan_token(67)) { + jj_scanpos = xsp; + if (jj_scan_token(68)) { + jj_scanpos = xsp; + if (jj_scan_token(69)) { + jj_scanpos = xsp; + if (jj_scan_token(71)) { + jj_scanpos = xsp; + if (jj_scan_token(72)) { + jj_scanpos = xsp; + if (jj_scan_token(73)) { + jj_scanpos = xsp; + if (jj_scan_token(26)) { + jj_scanpos = xsp; + if (jj_scan_token(51)) { + jj_scanpos = xsp; + if (jj_scan_token(89)) return true; + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + private boolean jj_3R_326() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_349()) { + jj_scanpos = xsp; + if (jj_3R_350()) return true; + } + return false; + } + + private boolean jj_3_2() + { + if (jj_3R_57()) return true; + return false; + } + + private boolean jj_3_23() + { + if (jj_scan_token(DOT)) return true; + if (jj_3R_86()) return true; + if (jj_3R_74()) return true; + return false; + } + + private boolean jj_3R_281() + { + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_88() + { + if (jj_3R_74()) return true; + return false; + } + + private boolean jj_3_1() + { + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_125() + { + if (jj_scan_token(DOT)) return true; + if (jj_3R_86()) return true; + if (jj_3R_74()) return true; + return false; + } + + private boolean jj_3R_109() + { + if (jj_3R_108()) return true; + if (jj_3R_75()) return true; + if (jj_3R_112()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_169()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_80() + { + if (jj_3R_86()) return true; + if (jj_3R_74()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_125()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3_43() + { + if (jj_3R_109()) return true; + return false; + } + + private boolean jj_3_42() + { + if (jj_3R_108()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_scan_token(19)) { + jj_scanpos = xsp; + if (jj_scan_token(39)) return true; + } + return false; + } + + private boolean jj_3R_132() + { + if (jj_3R_195()) return true; + return false; + } + + private boolean jj_3R_167() + { + if (jj_3R_75()) return true; + return false; + } + + private boolean jj_3R_166() + { + if (jj_scan_token(VOID)) return true; + return false; + } + + private boolean jj_3R_131() + { + if (jj_3R_109()) return true; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_130() + { + if (jj_3R_108()) return true; + if (jj_3R_194()) return true; + return false; + } + + private boolean jj_3R_102() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_166()) { + jj_scanpos = xsp; + if (jj_3R_167()) return true; + } + return false; + } + + private boolean jj_3R_336() + { + if (jj_scan_token(COLON)) return true; + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_84() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_130()) { + jj_scanpos = xsp; + if (jj_3R_131()) { + jj_scanpos = xsp; + if (jj_3R_132()) return true; + } + } + return false; + } + + private boolean jj_3R_160() + { + if (jj_scan_token(DOUBLE)) return true; + return false; + } + + private boolean jj_3R_159() + { + if (jj_scan_token(FLOAT)) return true; + return false; + } + + private boolean jj_3R_158() + { + if (jj_scan_token(LONG)) return true; + return false; + } + + private boolean jj_3R_157() + { + if (jj_scan_token(INT)) return true; + return false; + } + + private boolean jj_3R_156() + { + if (jj_scan_token(SHORT)) return true; + return false; + } + + private boolean jj_3R_155() + { + if (jj_scan_token(BYTE)) return true; + return false; + } + + private boolean jj_3R_154() + { + if (jj_scan_token(CHAR)) return true; + return false; + } + + private boolean jj_3R_358() + { + if (jj_scan_token(SUPER)) return true; + if (jj_3R_86()) return true; + if (jj_3R_85()) return true; + return false; + } + + private boolean jj_3R_226() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_199()) return true; + return false; + } + + private boolean jj_3R_153() + { + if (jj_scan_token(BOOLEAN)) return true; + return false; + } + + private boolean jj_3R_357() + { + if (jj_scan_token(EXTENDS)) return true; + if (jj_3R_86()) return true; + if (jj_3R_85()) return true; + return false; + } + + private boolean jj_3R_342() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_357()) { + jj_scanpos = xsp; + if (jj_3R_358()) return true; + } + return false; + } + + private boolean jj_3R_97() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_153()) { + jj_scanpos = xsp; + if (jj_3R_154()) { + jj_scanpos = xsp; + if (jj_3R_155()) { + jj_scanpos = xsp; + if (jj_3R_156()) { + jj_scanpos = xsp; + if (jj_3R_157()) { + jj_scanpos = xsp; + if (jj_3R_158()) { + jj_scanpos = xsp; + if (jj_3R_159()) { + jj_scanpos = xsp; + if (jj_3R_160()) return true; + } + } + } + } + } + } + } + return false; + } + + private boolean jj_3R_121() + { + if (jj_scan_token(LBRACE)) return true; + if (jj_3R_179()) return true; + if (jj_scan_token(RBRACE)) return true; + return false; + } + + private boolean jj_3R_295() + { + if (jj_scan_token(HOOK)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_342()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_107() + { + if (jj_3R_88()) return true; + if (jj_scan_token(COLON)) return true; + if (jj_3R_195()) return true; + return false; + } + + private boolean jj_3R_280() + { + if (jj_scan_token(ASSERT)) return true; + if (jj_3R_90()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_336()) jj_scanpos = xsp; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_247() + { + if (jj_3R_295()) return true; + return false; + } + + private boolean jj_3R_246() + { + if (jj_3R_75()) return true; + return false; + } + + private boolean jj_3R_242() + { + if (jj_3R_293()) return true; + return false; + } + + private boolean jj_3R_199() + { + if (jj_3R_86()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_246()) { + jj_scanpos = xsp; + if (jj_3R_247()) return true; + } + return false; + } + + private boolean jj_3R_241() + { + if (jj_3R_292()) return true; + return false; + } + + private boolean jj_3R_240() + { + if (jj_3R_291()) return true; + return false; + } + + private boolean jj_3R_239() + { + if (jj_3R_290()) return true; + return false; + } + + private boolean jj_3R_238() + { + if (jj_3R_289()) return true; + return false; + } + + private boolean jj_3R_136() + { + if (jj_3R_199()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_226()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_237() + { + if (jj_3R_288()) return true; + return false; + } + + private boolean jj_3R_236() + { + if (jj_3R_287()) return true; + return false; + } + + private boolean jj_3R_87() + { + if (jj_scan_token(LT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_136()) jj_scanpos = xsp; + if (jj_scan_token(GT)) return true; + return false; + } + + private boolean jj_3R_235() + { + if (jj_3R_286()) return true; + return false; + } + + private boolean jj_3R_234() + { + if (jj_3R_285()) return true; + return false; + } + + private boolean jj_3R_233() + { + if (jj_3R_284()) return true; + return false; + } + + private boolean jj_3_22() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3R_232() + { + if (jj_3R_283()) return true; + return false; + } + + private boolean jj_3R_231() + { + if (jj_3R_282()) return true; + return false; + } + + private boolean jj_3_21() + { + if (jj_scan_token(DOT)) return true; + if (jj_3R_86()) return true; + if (jj_3R_88()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_22()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_230() + { + if (jj_3R_281()) return true; + return false; + } + + private boolean jj_3R_229() + { + if (jj_3R_121()) return true; + return false; + } + + private boolean jj_3R_393() + { + if (jj_scan_token(THROWS)) return true; + if (jj_3R_249()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_403()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_228() + { + if (jj_3R_280()) return true; + return false; + } + + private boolean jj_3_19() + { + if (jj_3R_86()) return true; + if (jj_scan_token(LBRACKET)) return true; + return false; + } + + private boolean jj_3_41() + { + if (jj_3R_107()) return true; + return false; + } + + private boolean jj_3_20() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3R_197() + { + if (jj_3R_88()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_20()) jj_scanpos = xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_21()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_195() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3_41()) { + jj_scanpos = xsp; + if (jj_3R_228()) { + jj_scanpos = xsp; + if (jj_3R_229()) { + jj_scanpos = xsp; + if (jj_3R_230()) { + jj_scanpos = xsp; + if (jj_3R_231()) { + jj_scanpos = xsp; + if (jj_3R_232()) { + jj_scanpos = xsp; + if (jj_3R_233()) { + jj_scanpos = xsp; + if (jj_3R_234()) { + jj_scanpos = xsp; + if (jj_3R_235()) { + jj_scanpos = xsp; + if (jj_3R_236()) { + jj_scanpos = xsp; + if (jj_3R_237()) { + jj_scanpos = xsp; + if (jj_3R_238()) { + jj_scanpos = xsp; + if (jj_3R_239()) { + jj_scanpos = xsp; + if (jj_3R_240()) { + jj_scanpos = xsp; + if (jj_3R_241()) { + jj_scanpos = xsp; + if (jj_3R_242()) return true; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return false; + } + + private boolean jj_3_18() + { + if (jj_3R_86()) return true; + if (jj_scan_token(LBRACKET)) return true; + return false; + } + + private boolean jj_3R_198() + { + if (jj_3R_119()) return true; + return false; + } + + private boolean jj_3R_306() + { + if (jj_3R_86()) return true; + if (jj_3R_197()) return true; + return false; + } + + private boolean jj_3_39() + { + if (jj_3R_105()) return true; + return false; + } + + private boolean jj_3R_196() + { + if (jj_3R_119()) return true; + return false; + } + + private boolean jj_3R_106() + { + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_341() + { + if (jj_3R_180()) return true; + return false; + } + + private boolean jj_3_40() + { + if (jj_3R_86()) return true; + if (jj_scan_token(LBRACKET)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_106()) jj_scanpos = xsp; + if (jj_scan_token(RBRACKET)) return true; + return false; + } + + private boolean jj_3R_313() + { + Token xsp; + if (jj_3_40()) return true; + while (true) { + xsp = jj_scanpos; + if (jj_3_40()) { jj_scanpos = xsp; break; } + } + xsp = jj_scanpos; + if (jj_3R_341()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_308() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_316() + { + if (jj_3R_183()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_39()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_315() + { + if (jj_3R_313()) return true; + return false; + } + + private boolean jj_3R_119() + { + if (jj_3R_86()) return true; + if (jj_scan_token(LBRACKET)) return true; + if (jj_scan_token(RBRACKET)) return true; + return false; + } + + private boolean jj_3R_314() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3R_279() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_314()) jj_scanpos = xsp; + if (jj_3R_306()) return true; + xsp = jj_scanpos; + if (jj_3R_315()) { + jj_scanpos = xsp; + if (jj_3R_316()) return true; + } + return false; + } + + private boolean jj_3R_278() + { + if (jj_3R_97()) return true; + if (jj_3R_313()) return true; + return false; + } + + private boolean jj_3R_134() + { + if (jj_3R_197()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_198()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_133() + { + if (jj_3R_97()) return true; + Token xsp; + if (jj_3R_196()) return true; + while (true) { + xsp = jj_scanpos; + if (jj_3R_196()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_85() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_133()) { + jj_scanpos = xsp; + if (jj_3R_134()) return true; + } + return false; + } + + private boolean jj_3R_222() + { + if (jj_scan_token(NEW)) return true; + if (jj_3R_86()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_278()) { + jj_scanpos = xsp; + if (jj_3R_279()) return true; + } + return false; + } + + private boolean jj_3R_118() + { + if (jj_3R_97()) return true; + return false; + } + + private boolean jj_3_17() + { + if (jj_3R_85()) return true; + return false; + } + + private boolean jj_3_58() + { + if (jj_3R_84()) return true; + return false; + } + + private boolean jj_3R_75() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3_17()) { + jj_scanpos = xsp; + if (jj_3R_118()) return true; + } + return false; + } + + private boolean jj_3R_264() + { + if (jj_3R_90()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_308()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_214() + { + if (jj_3R_264()) return true; + return false; + } + + private boolean jj_3R_120() + { + if (jj_scan_token(STATIC)) return true; + return false; + } + + private boolean jj_3R_183() + { + if (jj_scan_token(LPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_214()) jj_scanpos = xsp; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + private boolean jj_3R_77() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_120()) jj_scanpos = xsp; + if (jj_3R_121()) return true; + return false; + } + + private boolean jj_3_16() + { + if (jj_3R_84()) return true; + return false; + } + + private boolean jj_3R_179() + { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_16()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3_14() + { + if (jj_3R_82()) return true; + if (jj_scan_token(DOT)) return true; + return false; + } + + private boolean jj_3R_340() + { + if (jj_scan_token(FALSE)) return true; + return false; + } + + private boolean jj_3R_310() + { + if (jj_scan_token(NULL)) return true; + return false; + } + + private boolean jj_3R_339() + { + if (jj_scan_token(TRUE)) return true; + return false; + } + + private boolean jj_3R_441() + { + if (jj_3R_442()) return true; + return false; + } + + private boolean jj_3R_83() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3R_185() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3_57() + { + if (jj_scan_token(REQUIRES)) return true; + if (jj_scan_token(TRANSITIVE)) return true; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3_15() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_83()) jj_scanpos = xsp; + if (jj_scan_token(THIS)) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + private boolean jj_3R_184() + { + if (jj_3R_82()) return true; + if (jj_scan_token(DOT)) return true; + return false; + } + + private boolean jj_3R_309() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_339()) { + jj_scanpos = xsp; + if (jj_3R_340()) return true; + } + return false; + } + + private boolean jj_3R_127() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_184()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_185()) jj_scanpos = xsp; + if (jj_scan_token(SUPER)) return true; + if (jj_3R_183()) return true; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_271() + { + if (jj_3R_310()) return true; + return false; + } + + private boolean jj_3R_182() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3R_270() + { + if (jj_3R_309()) return true; + return false; + } + + private boolean jj_3R_126() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_182()) jj_scanpos = xsp; + if (jj_scan_token(THIS)) return true; + if (jj_3R_183()) return true; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_269() + { + if (jj_scan_token(STRING_LITERAL)) return true; + return false; + } + + private boolean jj_3R_268() + { + if (jj_scan_token(CHARACTER_LITERAL)) return true; + return false; + } + + private boolean jj_3R_81() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_126()) { + jj_scanpos = xsp; + if (jj_3R_127()) return true; + } + return false; + } + + private boolean jj_3R_267() + { + if (jj_scan_token(FLOATING_POINT_LITERAL)) return true; + return false; + } + + private boolean jj_3R_266() + { + if (jj_scan_token(LONG_LITERAL)) return true; + return false; + } + + private boolean jj_3_13() + { + if (jj_3R_81()) return true; + return false; + } + + private boolean jj_3R_265() + { + if (jj_scan_token(INTEGER_LITERAL)) return true; + return false; + } + + private boolean jj_3R_104() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3R_164() + { + if (jj_3R_86()) return true; + if (jj_scan_token(ELLIPSIS)) return true; + return false; + } + + private boolean jj_3_38() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_104()) jj_scanpos = xsp; + if (jj_3R_74()) return true; + return false; + } + + private boolean jj_3R_394() + { + if (jj_3R_81()) return true; + return false; + } + + private boolean jj_3R_215() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_265()) { + jj_scanpos = xsp; + if (jj_3R_266()) { + jj_scanpos = xsp; + if (jj_3R_267()) { + jj_scanpos = xsp; + if (jj_3R_268()) { + jj_scanpos = xsp; + if (jj_3R_269()) { + jj_scanpos = xsp; + if (jj_3R_270()) { + jj_scanpos = xsp; + if (jj_3R_271()) return true; + } + } + } + } + } + } + return false; + } + + private boolean jj_3R_442() + { + if (jj_scan_token(_DEFAULT)) return true; + if (jj_3R_114()) return true; + return false; + } + + private boolean jj_3R_163() + { + if (jj_scan_token(LBRACKET)) return true; + if (jj_3R_90()) return true; + if (jj_scan_token(RBRACKET)) return true; + return false; + } + + private boolean jj_3R_254() + { + if (jj_3R_183()) return true; + return false; + } + + private boolean jj_3R_403() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_249()) return true; + return false; + } + + private boolean jj_3R_224() + { + if (jj_3R_74()) return true; + return false; + } + + private boolean jj_3R_253() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3R_365() + { + if (jj_3R_117()) return true; + return false; + } + + private boolean jj_3R_353() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_365()) jj_scanpos = xsp; + if (jj_3R_88()) return true; + if (jj_3R_392()) return true; + xsp = jj_scanpos; + if (jj_3R_393()) jj_scanpos = xsp; + if (jj_scan_token(LBRACE)) return true; + xsp = jj_scanpos; + if (jj_3R_394()) jj_scanpos = xsp; + if (jj_3R_179()) return true; + if (jj_scan_token(RBRACE)) return true; + return false; + } + + private boolean jj_3R_205() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_253()) jj_scanpos = xsp; + if (jj_3R_88()) return true; + xsp = jj_scanpos; + if (jj_3R_254()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_204() + { + if (jj_3R_222()) return true; + return false; + } + + private boolean jj_3_12() + { + if (jj_3R_80()) return true; + return false; + } + + private boolean jj_3_56() + { + if (jj_scan_token(ENUM)) return true; + return false; + } + + private boolean jj_3R_203() + { + if (jj_scan_token(THIS)) return true; + return false; + } + + private boolean jj_3R_439() + { + if (jj_3R_75()) return true; + if (jj_3R_88()) return true; + if (jj_scan_token(LPAREN)) return true; + if (jj_scan_token(RPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_441()) jj_scanpos = xsp; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3_55() + { + if (jj_3R_75()) return true; + if (jj_3R_74()) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + private boolean jj_3R_438() + { + if (jj_3R_354()) return true; + return false; + } + + private boolean jj_3R_437() + { + if (jj_3R_352()) return true; + return false; + } + + private boolean jj_3R_436() + { + if (jj_3R_351()) return true; + return false; + } + + private boolean jj_3R_181() + { + if (jj_3R_80()) return true; + if (jj_scan_token(DOT)) return true; + return false; + } + + private boolean jj_3R_162() + { + if (jj_scan_token(DOT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_203()) { + jj_scanpos = xsp; + if (jj_3R_204()) { + jj_scanpos = xsp; + if (jj_3R_205()) return true; + } + } + return false; + } + + private boolean jj_3R_435() + { + if (jj_3R_194()) return true; + return false; + } + + private boolean jj_3R_124() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_181()) jj_scanpos = xsp; + if (jj_3R_86()) return true; + if (jj_scan_token(THIS)) return true; + return false; + } + + private boolean jj_3R_434() + { + if (jj_3R_439()) return true; + return false; + } + + private boolean jj_3_54() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_114()) return true; + return false; + } + + private boolean jj_3R_99() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_162()) { + jj_scanpos = xsp; + if (jj_3R_163()) return true; + } + return false; + } + + private boolean jj_3R_311() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_100()) return true; + return false; + } + + private boolean jj_3R_223() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3R_79() + { + if (jj_3R_86()) return true; + if (jj_3R_75()) return true; + if (jj_3R_124()) return true; + return false; + } + + private boolean jj_3R_161() + { + if (jj_scan_token(DOT)) return true; + if (jj_scan_token(SUPER)) return true; + return false; + } + + private boolean jj_3R_429() + { + if (jj_3R_108()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_434()) { + jj_scanpos = xsp; + if (jj_3R_435()) { + jj_scanpos = xsp; + if (jj_3R_436()) { + jj_scanpos = xsp; + if (jj_3R_437()) { + jj_scanpos = xsp; + if (jj_3R_438()) return true; + } + } + } + } + return false; + } + + private boolean jj_3_37() + { + if (jj_3R_99()) return true; + return false; + } + + private boolean jj_3R_417() + { + if (jj_3R_429()) return true; + return false; + } + + private boolean jj_3R_401() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_417()) { + jj_scanpos = xsp; + if (jj_scan_token(98)) return true; + } + return false; + } + + private boolean jj_3R_275() + { + if (jj_3R_74()) return true; + return false; + } + + private boolean jj_3R_98() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3_37()) { + jj_scanpos = xsp; + if (jj_3R_161()) return true; + } + return false; + } + + private boolean jj_3R_225() + { + if (jj_3R_183()) return true; + return false; + } + + private boolean jj_3R_391() + { + if (jj_scan_token(LBRACE)) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_401()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(RBRACE)) return true; + return false; + } + + private boolean jj_3R_193() + { + if (jj_3R_88()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_225()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_100() + { + if (jj_3R_108()) return true; + if (jj_3R_75()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_164()) jj_scanpos = xsp; + if (jj_3R_101()) return true; + return false; + } + + private boolean jj_3_36() + { + if (jj_3R_103()) return true; + if (jj_scan_token(DOUBLECOLON)) return true; + return false; + } + + private boolean jj_3_35() + { + if (jj_3R_102()) return true; + if (jj_scan_token(DOT)) return true; + if (jj_scan_token(CLASS)) return true; + return false; + } + + private boolean jj_3R_312() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_101()) return true; + return false; + } + + private boolean jj_3R_352() + { + if (jj_scan_token(AT)) return true; + if (jj_scan_token(INTERFACE)) return true; + if (jj_3R_88()) return true; + if (jj_3R_391()) return true; + return false; + } + + private boolean jj_3R_192() + { + if (jj_3R_103()) return true; + if (jj_scan_token(DOUBLECOLON)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_223()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_224()) { + jj_scanpos = xsp; + if (jj_scan_token(42)) return true; + } + return false; + } + + private boolean jj_3_34() + { + if (jj_3R_101()) return true; + if (jj_scan_token(COMMA)) return true; + return false; + } + + private boolean jj_3R_277() + { + if (jj_3R_101()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_312()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_191() + { + if (jj_3R_102()) return true; + if (jj_scan_token(DOT)) return true; + if (jj_scan_token(CLASS)) return true; + return false; + } + + private boolean jj_3_33() + { + if (jj_3R_100()) return true; + return false; + } + + private boolean jj_3R_190() + { + if (jj_3R_222()) return true; + return false; + } + + private boolean jj_3R_346() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_345()) return true; + return false; + } + + private boolean jj_3R_221() + { + if (jj_3R_90()) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + private boolean jj_3R_362() + { + if (jj_3R_114()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_54()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_274() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3_10() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_78()) return true; + return false; + } + + private boolean jj_3R_220() + { + if (jj_3R_277()) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + private boolean jj_3R_276() + { + if (jj_3R_100()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_311()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_218() + { + if (jj_scan_token(RPAREN)) return true; + return false; + } + + private boolean jj_3_11() + { + if (jj_3R_79()) return true; + return false; + } + + private boolean jj_3R_219() + { + if (jj_3R_276()) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + private boolean jj_3R_212() + { + if (jj_scan_token(LBRACE)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_362()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_scan_token(99)) jj_scanpos = xsp; + if (jj_scan_token(RBRACE)) return true; + return false; + } + + private boolean jj_3R_217() + { + if (jj_scan_token(DOUBLECOLON)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_274()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_275()) { + jj_scanpos = xsp; + if (jj_scan_token(42)) return true; + } + return false; + } + + private boolean jj_3R_420() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_100()) return true; + return false; + } + + private boolean jj_3R_419() + { + if (jj_3R_100()) return true; + return false; + } + + private boolean jj_3R_189() + { + if (jj_scan_token(LPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_218()) { + jj_scanpos = xsp; + if (jj_3R_219()) { + jj_scanpos = xsp; + if (jj_3R_220()) { + jj_scanpos = xsp; + if (jj_3R_221()) return true; + } + } + } + return false; + } + + private boolean jj_3R_176() + { + if (jj_3R_149()) return true; + return false; + } + + private boolean jj_3_53() + { + if (jj_scan_token(AT)) return true; + return false; + } + + private boolean jj_3R_175() + { + if (jj_3R_212()) return true; + return false; + } + + private boolean jj_3R_396() + { + if (jj_3R_119()) return true; + return false; + } + + private boolean jj_3R_418() + { + if (jj_3R_79()) return true; + return false; + } + + private boolean jj_3R_402() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_418()) { + jj_scanpos = xsp; + if (jj_3R_419()) return true; + } + while (true) { + xsp = jj_scanpos; + if (jj_3R_420()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_273() + { + if (jj_3R_183()) return true; + return false; + } + + private boolean jj_3R_174() + { + if (jj_3R_115()) return true; + return false; + } + + private boolean jj_3R_392() + { + if (jj_scan_token(LPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_402()) jj_scanpos = xsp; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + private boolean jj_3R_216() + { + if (jj_scan_token(DOT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_272()) jj_scanpos = xsp; + if (jj_3R_88()) return true; + xsp = jj_scanpos; + if (jj_3R_273()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_272() + { + if (jj_3R_87()) return true; + return false; + } + + private boolean jj_3R_114() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_174()) { + jj_scanpos = xsp; + if (jj_3R_175()) { + jj_scanpos = xsp; + if (jj_3R_176()) return true; + } + } + return false; + } + + private boolean jj_3_32() + { + if (jj_3R_99()) return true; + return false; + } + + private boolean jj_3R_188() + { + if (jj_scan_token(SUPER)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_216()) { + jj_scanpos = xsp; + if (jj_3R_217()) return true; + } + return false; + } + + private boolean jj_3R_187() + { + if (jj_scan_token(THIS)) return true; + return false; + } + + private boolean jj_3R_345() + { + if (jj_3R_88()) return true; + if (jj_scan_token(ASSIGN)) return true; + if (jj_3R_114()) return true; + return false; + } + + private boolean jj_3R_186() + { + if (jj_3R_215()) return true; + return false; + } + + private boolean jj_3R_103() + { + if (jj_3R_86()) return true; + if (jj_3R_75()) return true; + return false; + } + + private boolean jj_3R_129() + { + if (jj_3R_99()) return true; + return false; + } + + private boolean jj_3R_113() + { + if (jj_3R_74()) return true; + if (jj_scan_token(ASSIGN)) return true; + return false; + } + + private boolean jj_3R_128() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_186()) { + jj_scanpos = xsp; + if (jj_3R_187()) { + jj_scanpos = xsp; + if (jj_3R_188()) { + jj_scanpos = xsp; + if (jj_3R_189()) { + jj_scanpos = xsp; + if (jj_3R_190()) { + jj_scanpos = xsp; + if (jj_3R_191()) { + jj_scanpos = xsp; + if (jj_3R_192()) { + jj_scanpos = xsp; + if (jj_3R_193()) return true; + } + } + } + } + } + } + } + return false; + } + + private boolean jj_3_52() + { + if (jj_scan_token(LPAREN)) return true; + return false; + } + + private boolean jj_3R_323() + { + if (jj_3R_345()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_346()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3_31() + { + if (jj_3R_98()) return true; + return false; + } + + private boolean jj_3R_249() + { + if (jj_3R_86()) return true; + if (jj_3R_85()) return true; + return false; + } + + private boolean jj_3_51() + { + if (jj_scan_token(LPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_113()) { + jj_scanpos = xsp; + if (jj_scan_token(93)) return true; + } + return false; + } + + private boolean jj_3R_245() + { + return false; + } + + private boolean jj_3R_294() + { + if (jj_3R_323()) return true; + return false; + } + + private boolean jj_3R_244() + { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_114()) return true; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + private boolean jj_3R_404() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_249()) return true; + return false; + } + + private boolean jj_3R_398() + { + if (jj_3R_121()) return true; + return false; + } + + private boolean jj_3R_243() + { + if (jj_scan_token(LPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_294()) jj_scanpos = xsp; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + private boolean jj_3R_397() + { + if (jj_scan_token(THROWS)) return true; + if (jj_3R_249()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_404()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_82() + { + if (jj_3R_128()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_129()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_366() + { + if (jj_3R_117()) return true; + return false; + } + + private boolean jj_3R_115() + { + if (jj_scan_token(AT)) return true; + if (jj_3R_80()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_243()) { + jj_scanpos = xsp; + if (jj_3R_244()) { + jj_scanpos = xsp; + if (jj_3R_245()) return true; + } + } + return false; + } + + private boolean jj_3R_335() + { + if (jj_3R_78()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_10()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_355() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_366()) jj_scanpos = xsp; + if (jj_3R_86()) return true; + if (jj_3R_102()) return true; + if (jj_3R_88()) return true; + if (jj_3R_392()) return true; + while (true) { + xsp = jj_scanpos; + if (jj_3R_396()) { jj_scanpos = xsp; break; } + } + xsp = jj_scanpos; + if (jj_3R_397()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_398()) { + jj_scanpos = xsp; + if (jj_scan_token(98)) return true; + } + return false; + } + + private boolean jj_3_50() + { + if (jj_scan_token(AT)) return true; + return false; + } + + private boolean jj_3R_211() + { + if (jj_3R_128()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_31()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_165() + { + if (jj_3R_119()) return true; + return false; + } + + private boolean jj_3R_135() + { + if (jj_3R_115()) return true; + return false; + } + + private boolean jj_3R_86() + { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_135()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_150() + { + return false; + } + + private boolean jj_3R_201() + { + if (jj_scan_token(BIT_AND)) return true; + if (jj_3R_249()) return true; + return false; + } + + private boolean jj_3_48() + { + if (jj_scan_token(SEMICOLON)) return true; + if (jj_3R_111()) return true; + return false; + } + + private boolean jj_3R_152() + { + if (jj_3R_85()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_201()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(RPAREN)) return true; + if (jj_3R_202()) return true; + return false; + } + + private boolean jj_3R_180() + { + if (jj_scan_token(LBRACE)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_335()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_scan_token(99)) jj_scanpos = xsp; + if (jj_scan_token(RBRACE)) return true; + return false; + } + + private boolean jj_3_30() + { + if (jj_3R_97()) return true; + if (jj_scan_token(RPAREN)) return true; + if (jj_3R_170()) return true; + return false; + } + + private boolean jj_3R_151() + { + return false; + } + + private boolean jj_3R_123() + { + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_92() + { + jj_lookingAhead = true; + jj_semLA = getToken(1).kind == GT && + getToken(1).realKind == RSIGNEDSHIFT; + jj_lookingAhead = false; + if (!jj_semLA || jj_3R_150()) return true; + if (jj_scan_token(GT)) return true; + if (jj_scan_token(GT)) return true; + return false; + } + + private boolean jj_3R_122() + { + if (jj_3R_180()) return true; + return false; + } + + private boolean jj_3R_173() + { + if (jj_scan_token(ASSIGN)) return true; + if (jj_3R_78()) return true; + return false; + } + + private boolean jj_3R_94() + { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_86()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_30()) { + jj_scanpos = xsp; + if (jj_3R_152()) return true; + } + return false; + } + + private boolean jj_3R_93() + { + jj_lookingAhead = true; + jj_semLA = getToken(1).kind == GT && + getToken(1).realKind == RUNSIGNEDSHIFT; + jj_lookingAhead = false; + if (!jj_semLA || jj_3R_151()) return true; + if (jj_scan_token(GT)) return true; + if (jj_scan_token(GT)) return true; + if (jj_scan_token(GT)) return true; + return false; + } + + private boolean jj_3R_78() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_122()) { + jj_scanpos = xsp; + if (jj_3R_123()) return true; + } + return false; + } + + private boolean jj_3_49() + { + if (jj_3R_108()) return true; + if (jj_3R_75()) return true; + if (jj_3R_112()) return true; + return false; + } + + private boolean jj_3R_172() + { + if (jj_3R_211()) return true; + return false; + } + + private boolean jj_3R_96() + { + if (jj_scan_token(DECR)) return true; + return false; + } + + private boolean jj_3_29() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_95()) { + jj_scanpos = xsp; + if (jj_3R_96()) return true; + } + return false; + } + + private boolean jj_3R_95() + { + if (jj_scan_token(INCR)) return true; + return false; + } + + private boolean jj_3_28() + { + if (jj_3R_94()) return true; + return false; + } + + private boolean jj_3R_101() + { + if (jj_3R_88()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_165()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_76() + { + if (jj_3R_119()) return true; + return false; + } + + private boolean jj_3R_171() + { + if (jj_3R_109()) return true; + return false; + } + + private boolean jj_3R_111() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_171()) { + jj_scanpos = xsp; + if (jj_3R_172()) return true; + } + return false; + } + + private boolean jj_3R_299() + { + if (jj_3R_211()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_29()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_251() + { + if (jj_3R_94()) return true; + return false; + } + + private boolean jj_3R_368() + { + if (jj_3R_111()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_48()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_298() + { + if (jj_scan_token(BANG)) return true; + return false; + } + + private boolean jj_3R_252() + { + if (jj_3R_299()) return true; + return false; + } + + private boolean jj_3R_297() + { + if (jj_scan_token(TILDE)) return true; + return false; + } + + private boolean jj_3R_112() + { + if (jj_3R_101()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_173()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_250() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_297()) { + jj_scanpos = xsp; + if (jj_3R_298()) return true; + } + if (jj_3R_170()) return true; + return false; + } + + private boolean jj_3R_395() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_112()) return true; + return false; + } + + private boolean jj_3R_73() + { + if (jj_3R_117()) return true; + return false; + } + + private boolean jj_3_8() + { + if (jj_3R_75()) return true; + if (jj_3R_74()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_76()) { jj_scanpos = xsp; break; } + } + xsp = jj_scanpos; + if (jj_scan_token(99)) { + jj_scanpos = xsp; + if (jj_scan_token(102)) { + jj_scanpos = xsp; + if (jj_scan_token(98)) return true; + } + } + return false; + } + + private boolean jj_3R_202() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_250()) { + jj_scanpos = xsp; + if (jj_3R_251()) { + jj_scanpos = xsp; + if (jj_3R_252()) return true; + } + } + return false; + } + + private boolean jj_3R_428() + { + if (jj_scan_token(FINALLY)) return true; + if (jj_3R_121()) return true; + return false; + } + + private boolean jj_3R_413() + { + if (jj_scan_token(FINALLY)) return true; + if (jj_3R_121()) return true; + return false; + } + + private boolean jj_3_7() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_73()) jj_scanpos = xsp; + if (jj_3R_74()) return true; + if (jj_scan_token(LPAREN)) return true; + return false; + } + + private boolean jj_3_47() + { + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_354() + { + if (jj_3R_75()) return true; + if (jj_3R_112()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_395()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_344() + { + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_368()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_47()) jj_scanpos = xsp; + if (jj_scan_token(RPAREN)) return true; + return false; + } + + private boolean jj_3_6() + { + if (jj_scan_token(AT)) return true; + if (jj_scan_token(INTERFACE)) return true; + return false; + } + + private boolean jj_3_5() + { + if (jj_scan_token(ENUM)) return true; + return false; + } + + private boolean jj_3R_334() + { + if (jj_3R_355()) return true; + return false; + } + + private boolean jj_3R_433() + { + if (jj_scan_token(BIT_OR)) return true; + if (jj_3R_249()) return true; + return false; + } + + private boolean jj_3R_333() + { + if (jj_3R_354()) return true; + return false; + } + + private boolean jj_3R_257() + { + if (jj_scan_token(DECR)) return true; + if (jj_3R_170()) return true; + return false; + } + + private boolean jj_3R_332() + { + if (jj_3R_353()) return true; + return false; + } + + private boolean jj_3R_427() + { + if (jj_scan_token(CATCH)) return true; + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_108()) return true; + if (jj_3R_85()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_433()) { jj_scanpos = xsp; break; } + } + if (jj_3R_101()) return true; + if (jj_scan_token(RPAREN)) return true; + if (jj_3R_121()) return true; + return false; + } + + private boolean jj_3R_331() + { + if (jj_3R_352()) return true; + return false; + } + + private boolean jj_3R_330() + { + if (jj_3R_351()) return true; + return false; + } + + private boolean jj_3R_329() + { + if (jj_3R_194()) return true; + return false; + } + + private boolean jj_3R_110() + { + if (jj_scan_token(INCR)) return true; + if (jj_3R_170()) return true; + return false; + } + + private boolean jj_3R_303() + { + if (jj_3R_108()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_329()) { + jj_scanpos = xsp; + if (jj_3R_330()) { + jj_scanpos = xsp; + if (jj_3R_331()) { + jj_scanpos = xsp; + if (jj_3R_332()) { + jj_scanpos = xsp; + if (jj_3R_333()) { + jj_scanpos = xsp; + if (jj_3R_334()) return true; + } + } + } + } + } + return false; + } + + private boolean jj_3R_210() + { + if (jj_3R_202()) return true; + return false; + } + + private boolean jj_3_9() + { + if (jj_3R_77()) return true; + return false; + } + + private boolean jj_3R_259() + { + if (jj_scan_token(MINUS)) return true; + return false; + } + + private boolean jj_3R_258() + { + if (jj_scan_token(PLUS)) return true; + return false; + } + + private boolean jj_3R_213() + { + if (jj_3R_263()) return true; + return false; + } + + private boolean jj_3R_412() + { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_427()) { jj_scanpos = xsp; break; } + } + xsp = jj_scanpos; + if (jj_3R_428()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_209() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_258()) { + jj_scanpos = xsp; + if (jj_3R_259()) return true; + } + if (jj_3R_170()) return true; + return false; + } + + private boolean jj_3R_208() + { + if (jj_3R_257()) return true; + return false; + } + + private boolean jj_3R_207() + { + if (jj_3R_110()) return true; + return false; + } + + private boolean jj_3R_256() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3_9()) { + jj_scanpos = xsp; + if (jj_3R_303()) return true; + } + return false; + } + + private boolean jj_3R_322() + { + if (jj_3R_344()) return true; + return false; + } + + private boolean jj_3R_293() + { + if (jj_scan_token(TRY)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_322()) jj_scanpos = xsp; + if (jj_3R_121()) return true; + xsp = jj_scanpos; + if (jj_3R_412()) { + jj_scanpos = xsp; + if (jj_3R_413()) return true; + } + return false; + } + + private boolean jj_3R_168() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_206()) { + jj_scanpos = xsp; + if (jj_scan_token(98)) return true; + } + return false; + } + + private boolean jj_3R_206() + { + if (jj_3R_256()) return true; + return false; + } + + private boolean jj_3R_170() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_207()) { + jj_scanpos = xsp; + if (jj_3R_208()) { + jj_scanpos = xsp; + if (jj_3R_209()) { + jj_scanpos = xsp; + if (jj_3R_210()) return true; + } + } + } + return false; + } + + private boolean jj_3R_423() + { + if (jj_scan_token(REM)) return true; + return false; + } + + private boolean jj_3R_105() + { + if (jj_scan_token(LBRACE)) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_168()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(RBRACE)) return true; + return false; + } + + private boolean jj_3R_422() + { + if (jj_scan_token(SLASH)) return true; + return false; + } + + private boolean jj_3R_421() + { + if (jj_scan_token(STAR)) return true; + return false; + } + + private boolean jj_3R_405() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_421()) { + jj_scanpos = xsp; + if (jj_3R_422()) { + jj_scanpos = xsp; + if (jj_3R_423()) return true; + } + } + if (jj_3R_170()) return true; + return false; + } + + private boolean jj_3R_321() + { + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_307() + { + if (jj_scan_token(BIT_AND)) return true; + if (jj_3R_306()) return true; + return false; + } + + private boolean jj_3R_382() + { + if (jj_3R_170()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_405()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_263() + { + if (jj_scan_token(EXTENDS)) return true; + if (jj_3R_306()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_307()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_292() + { + if (jj_scan_token(SYNCHRONIZED)) return true; + if (jj_scan_token(LPAREN)) return true; + if (jj_3R_90()) return true; + if (jj_scan_token(RPAREN)) return true; + if (jj_3R_121()) return true; + return false; + } + + private boolean jj_3R_320() + { + if (jj_3R_88()) return true; + return false; + } + + private boolean jj_3R_407() + { + if (jj_scan_token(MINUS)) return true; + return false; + } + + private boolean jj_3R_406() + { + if (jj_scan_token(PLUS)) return true; + return false; + } + + private boolean jj_3R_399() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_406()) { + jj_scanpos = xsp; + if (jj_3R_407()) return true; + } + if (jj_3R_382()) return true; + return false; + } + + private boolean jj_3_4() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_72()) return true; + return false; + } + + private boolean jj_3R_177() + { + if (jj_3R_88()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_213()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_291() + { + if (jj_scan_token(THROW)) return true; + if (jj_3R_90()) return true; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_378() + { + if (jj_3R_382()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_399()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_319() + { + if (jj_3R_88()) return true; + return false; + } + + private boolean jj_3R_415() + { + if (jj_3R_105()) return true; + return false; + } + + private boolean jj_3R_178() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_86()) return true; + if (jj_3R_177()) return true; + return false; + } + + private boolean jj_3_27() + { + if (jj_3R_93()) return true; + return false; + } + + private boolean jj_3_26() + { + if (jj_3R_92()) return true; + return false; + } + + private boolean jj_3R_440() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_290() + { + if (jj_scan_token(RETURN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_321()) jj_scanpos = xsp; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_91() + { + if (jj_scan_token(LSHIFT)) return true; + return false; + } + + private boolean jj_3_25() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_91()) { + jj_scanpos = xsp; + if (jj_3_26()) { + jj_scanpos = xsp; + if (jj_3_27()) return true; + } + } + if (jj_3R_378()) return true; + return false; + } + + private boolean jj_3R_117() + { + if (jj_scan_token(LT)) return true; + if (jj_3R_86()) return true; + if (jj_3R_177()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_178()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(GT)) return true; + return false; + } + + private boolean jj_3R_379() + { + if (jj_scan_token(INSTANCEOF)) return true; + if (jj_3R_249()) return true; + return false; + } + + private boolean jj_3R_376() + { + if (jj_3R_378()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_25()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_289() + { + if (jj_scan_token(CONTINUE)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_320()) jj_scanpos = xsp; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_387() + { + if (jj_scan_token(GE)) return true; + return false; + } + + private boolean jj_3R_386() + { + if (jj_scan_token(LE)) return true; + return false; + } + + private boolean jj_3R_426() + { + if (jj_3R_432()) return true; + return false; + } + + private boolean jj_3R_385() + { + if (jj_scan_token(GT)) return true; + return false; + } + + private boolean jj_3R_384() + { + if (jj_scan_token(LT)) return true; + return false; + } + + private boolean jj_3R_414() + { + if (jj_3R_183()) return true; + return false; + } + + private boolean jj_3R_383() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_384()) { + jj_scanpos = xsp; + if (jj_3R_385()) { + jj_scanpos = xsp; + if (jj_3R_386()) { + jj_scanpos = xsp; + if (jj_3R_387()) return true; + } + } + } + if (jj_3R_376()) return true; + return false; + } + + private boolean jj_3R_288() + { + if (jj_scan_token(BREAK)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_319()) jj_scanpos = xsp; + if (jj_scan_token(SEMICOLON)) return true; + return false; + } + + private boolean jj_3R_116() + { + if (jj_3R_115()) return true; + return false; + } + + private boolean jj_3R_72() + { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_116()) { jj_scanpos = xsp; break; } + } + if (jj_3R_88()) return true; + xsp = jj_scanpos; + if (jj_3R_414()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_415()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_373() + { + if (jj_3R_376()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_383()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_432() + { + if (jj_3R_375()) return true; + return false; + } + + private boolean jj_3R_416() + { + if (jj_3R_256()) return true; + return false; + } + + private boolean jj_3R_411() + { + if (jj_scan_token(ELSE)) return true; + if (jj_3R_195()) return true; + return false; + } + + private boolean jj_3R_400() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_416()) { + jj_scanpos = xsp; + if (jj_scan_token(98)) return true; + } + return false; + } + + private boolean jj_3_46() + { + if (jj_3R_108()) return true; + if (jj_3R_75()) return true; + if (jj_3R_74()) return true; + return false; + } + + private boolean jj_3R_374() + { + if (jj_scan_token(BIT_AND)) return true; + if (jj_3R_363()) return true; + return false; + } + + private boolean jj_3R_369() + { + if (jj_3R_373()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_379()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_390() + { + if (jj_scan_token(SEMICOLON)) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_400()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_375() + { + if (jj_3R_90()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_440()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_372() + { + if (jj_3R_375()) return true; + return false; + } + + private boolean jj_3R_425() + { + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_389() + { + if (jj_3R_72()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_4()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_371() + { + if (jj_3R_109()) return true; + return false; + } + + private boolean jj_3R_388() + { + if (jj_3R_305()) return true; + return false; + } + + private boolean jj_3R_381() + { + if (jj_scan_token(NE)) return true; + return false; + } + + private boolean jj_3R_380() + { + if (jj_scan_token(EQ)) return true; + return false; + } + + private boolean jj_3R_377() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_380()) { + jj_scanpos = xsp; + if (jj_3R_381()) return true; + } + if (jj_3R_369()) return true; + return false; + } + + private boolean jj_3R_370() + { + if (jj_scan_token(XOR)) return true; + if (jj_3R_347()) return true; + return false; + } + + private boolean jj_3R_351() + { + if (jj_scan_token(ENUM)) return true; + if (jj_3R_88()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_388()) jj_scanpos = xsp; + if (jj_scan_token(LBRACE)) return true; + xsp = jj_scanpos; + if (jj_3R_389()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_scan_token(99)) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_390()) jj_scanpos = xsp; + if (jj_scan_token(RBRACE)) return true; + return false; + } + + private boolean jj_3R_367() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_371()) { + jj_scanpos = xsp; + if (jj_3R_372()) return true; + } + return false; + } + + private boolean jj_3R_364() + { + if (jj_scan_token(BIT_OR)) return true; + if (jj_3R_324()) return true; + return false; + } + + private boolean jj_3R_363() + { + if (jj_3R_369()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_377()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3_45() + { + if (jj_3R_109()) return true; + if (jj_scan_token(COLON)) return true; + return false; + } + + private boolean jj_3R_348() + { + if (jj_scan_token(SC_AND)) return true; + if (jj_3R_296()) return true; + return false; + } + + private boolean jj_3R_409() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_306()) return true; + return false; + } + + private boolean jj_3R_347() + { + if (jj_3R_363()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_374()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_356() + { + if (jj_3R_367()) return true; + return false; + } + + private boolean jj_3R_305() + { + if (jj_scan_token(IMPLEMENTS)) return true; + if (jj_3R_306()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_409()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_338() + { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_356()) jj_scanpos = xsp; + if (jj_scan_token(SEMICOLON)) return true; + xsp = jj_scanpos; + if (jj_3R_425()) jj_scanpos = xsp; + if (jj_scan_token(SEMICOLON)) return true; + xsp = jj_scanpos; + if (jj_3R_426()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_325() + { + if (jj_scan_token(SC_OR)) return true; + if (jj_3R_248()) return true; + return false; + } + + private boolean jj_3R_337() + { + if (jj_3R_109()) return true; + if (jj_scan_token(COLON)) return true; + if (jj_3R_90()) return true; + return false; + } + + private boolean jj_3R_324() + { + if (jj_3R_347()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_370()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_408() + { + if (jj_scan_token(COMMA)) return true; + if (jj_3R_306()) return true; + return false; + } + + private boolean jj_3R_287() + { + if (jj_scan_token(FOR)) return true; + if (jj_scan_token(LPAREN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_337()) { + jj_scanpos = xsp; + if (jj_3R_338()) return true; + } + if (jj_scan_token(RPAREN)) return true; + if (jj_3R_195()) return true; + return false; + } + + /** Generated Token Manager. */ + public GeneratedJavaParserTokenManager token_source; + SimpleCharStream jj_input_stream; + /** Current token. */ + public Token token; + /** Next token. */ + public Token jj_nt; + private int jj_ntk; + private Token jj_scanpos, jj_lastpos; + private int jj_la; + /** Whether we are looking ahead. */ + private boolean jj_lookingAhead = false; + private boolean jj_semLA; + private int jj_gen; + final private int[] jj_la1 = new int[164]; + static private int[] jj_la1_0; + static private int[] jj_la1_1; + static private int[] jj_la1_2; + static private int[] jj_la1_3; + static private int[] jj_la1_4; + static { + jj_la1_init_0(); + jj_la1_init_1(); + jj_la1_init_2(); + jj_la1_init_3(); + jj_la1_init_4(); + } + private static void jj_la1_init_0() { + jj_la1_0 = new int[] {0x24480800,0x4080000,0x24480800,0x1,0x0,0x0,0x20400800,0x80000,0x0,0x8000000,0x0,0x0,0x0,0x0,0x4000000,0x0,0xa54ca800,0xa54ca800,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0xa54ca800,0xa54ca800,0x80000,0x8504a000,0xa54ca800,0x0,0x0,0x0,0x9504a000,0x9504a000,0x0,0x0,0x0,0x0,0x0,0x0,0xa544a800,0x0,0xa544a800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,0x0,0x8104a000,0x8504a000,0x8504a000,0x0,0x8504a000,0x8504a000,0x8000000,0x8000000,0x8104a000,0x8504a000,0x4000000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,0x0,0x0,0x9504a000,0x0,0x0,0x8504a000,0x0,0x0,0x0,0x4000000,0x0,0x0,0x9504a000,0x0,0x4000000,0x0,0x10000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x9504a000,0x0,0x0,0x0,0x8504a000,0x9504a000,0x0,0x95a4f000,0x0,0x95a4f000,0x0,0x9504a000,0x0,0x0,0x9504a000,0x410000,0x410000,0x2000000,0xb544a800,0x9504a000,0x9504a000,0xb544a800,0x9504a000,0x0,0x4000000,0x4000000,0x9504a000,0x0,0x20000,0x0,0x40000000,0x9504a000,0x4000000,0x0,0x9504a000,0x9504a000,0x0,0xa54ca800,0xa54ca800,0x80000,0x8504a000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,}; + } + private static void jj_la1_init_1() { + jj_la1_1 = new int[] {0x444ce290,0x80,0x444ce290,0x0,0x40000,0x0,0x444ce200,0x80,0x0,0x0,0x8,0x0,0x0,0x8,0x80000,0x0,0x644ee3c0,0x644ee3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x644ee3c0,0x644ee3c0,0x80,0x200a0140,0x644ee3c0,0x0,0x0,0x0,0x289a0d40,0x289a0d40,0x0,0x0,0x0,0x0,0x2000000,0x0,0x444ee340,0x0,0x444ee340,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x289a0d40,0x40000,0x20140,0xa0140,0xa0140,0x0,0xa0140,0xa0140,0x100000,0x100000,0x20140,0x200a0140,0x80000,0x0,0x80400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x289a0d40,0x0,0x0,0x289a0d40,0x0,0x0,0xa0140,0x0,0x0,0x0,0x80400,0x0,0x0,0x289a0d40,0x0,0x80400,0x0,0x8900c00,0x80000,0x0,0x0,0x0,0x800400,0x0,0x8000800,0x8000000,0x289a0d40,0x0,0x0,0x0,0xa0140,0x289a0d40,0x0,0xb9fb0d45,0x0,0xb9fb0d45,0x0,0x289a0d40,0x0,0x0,0x289a0d40,0x0,0x0,0x0,0x6cdeef40,0x289a0d40,0x289a0d40,0x6cdeef40,0x289a0d40,0x0,0x80000,0x80000,0x289a0d40,0x0,0x0,0x0,0x0,0x289a0d40,0x80000,0x0,0x289a0d40,0x289a0d40,0x0,0x444ee3c0,0x444ee3c0,0x80,0xa0140,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x289a0d40,}; + } + private static void jj_la1_init_2() { + jj_la1_2 = new int[] {0x248,0x48,0x248,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20003ff,0x0,0x420003ff,0x420003ff,0x0,0x0,0x10000000,0x40000000,0x0,0x0,0x0,0x420003ff,0x420003ff,0x0,0x20003ff,0x20003ff,0x0,0x0,0x0,0x53810fff,0x53810fff,0x0,0x0,0x0,0x0,0x0,0x40000000,0x20003ff,0x0,0x20003ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x13810fff,0x0,0x0,0x20003ff,0x20003ff,0x0,0x20003ff,0x20003ff,0x0,0x0,0x0,0x20003ff,0x20003ff,0x0,0x20003ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x13810fff,0x0,0x0,0x13810fff,0x0,0x0,0x20003ff,0x0,0x10000000,0x0,0x20003ff,0x0,0x20000000,0x13810fff,0x0,0x20003ff,0x10000000,0x11810c00,0x20003ff,0x0,0x0,0x10000000,0x0,0x0,0x1810c00,0x0,0x13810fff,0x0,0x0,0x10000000,0x20003ff,0x13810fff,0x40000000,0x53810fff,0x0,0x53810fff,0x0,0x53810fff,0x0,0x0,0x13810fff,0x0,0x0,0x0,0x13810fff,0x13810fff,0x13810fff,0x13810fff,0x13810fff,0x0,0x20003ff,0x20003ff,0x13810fff,0x10000000,0x0,0x0,0x0,0x13810fff,0x20003ff,0x0,0x53810fff,0x53810fff,0x0,0x20003ff,0x20003ff,0x0,0x20003ff,0x0,0x0,0x2,0x0,0x2,0x0,0x1b1,0x8,0x1b1,0x13810fff,}; + } + private static void jj_la1_init_3() { + jj_la1_3 = new int[] {0x24,0x24,0x24,0x0,0x0,0x10,0x20,0x0,0x80,0x0,0x0,0x8,0x8,0x0,0x20,0x8,0xa4,0xa4,0x4,0x20,0x0,0x0,0x8,0x0,0x1000000,0xa4,0xa4,0x0,0xa0,0xa0,0x8,0x40,0x21,0x3c0320,0x3c0320,0x8,0x80,0x21,0x8,0x0,0x4,0x20,0x8,0x20,0x8,0x8,0x20,0x80,0x8,0x0,0x80,0x80,0xa0,0x0,0x0,0x0,0x20,0x8,0x420,0x400,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0xe0000040,0xe0000040,0x400,0x10000,0x20000,0x2000000,0x4000000,0x1000000,0x9000,0x9000,0x0,0x6080,0x6080,0x10000000,0x300000,0x300000,0x8c00000,0x8c00000,0x300000,0x3c0320,0x300,0x300,0x20,0xc0000,0x1000000,0x0,0x80,0x0,0x80,0x0,0x10,0x0,0x3c0320,0x80,0x0,0x0,0x0,0x0,0x10,0x80,0x0,0x0,0x11,0x0,0x0,0x3c0320,0x8,0x80,0x21,0xa0,0x3c0320,0x0,0xc0024,0x800,0xc0024,0x8,0x3c0320,0xe00c0040,0xe00c0040,0x80020,0x0,0x0,0x0,0x3c0320,0x3c0320,0x3c0320,0x3c0324,0x3c0320,0x8,0x0,0x0,0x3c0320,0x0,0x0,0x2000000,0x0,0x20,0x0,0x8,0x3c0320,0x3c0320,0x8,0x24,0x24,0x0,0x20,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x0,0x0,0xa0,}; + } + private static void jj_la1_init_4() { + jj_la1_4 = new int[] {0x0,0x0,0x0,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x6ff,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x2000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + } + final private JJCalls[] jj_2_rtns = new JJCalls[58]; + private boolean jj_rescan = false; + private int jj_gc = 0; + + /** Constructor. */ + public GeneratedJavaParser(Provider stream) { + jj_input_stream = new SimpleCharStream(stream, 1, 1); + token_source = new GeneratedJavaParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 164; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + /** Constructor. */ + public GeneratedJavaParser(String dsl) throws ParseException, TokenMgrException { + this(new StringProvider(dsl)); + } + + public void ReInit(String s) { + ReInit(new StringProvider(s)); + } + /** Reinitialise. */ + public void ReInit(Provider stream) { + if (jj_input_stream == null) { + jj_input_stream = new SimpleCharStream(stream, 1, 1); + } else { + jj_input_stream.ReInit(stream, 1, 1); + } + if (token_source == null) { + token_source = new GeneratedJavaParserTokenManager(jj_input_stream); + } + + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 164; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + /** Constructor with generated Token Manager. */ + public GeneratedJavaParser(GeneratedJavaParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 164; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + /** Reinitialise. */ + public void ReInit(GeneratedJavaParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 164; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + private Token jj_consume_token(int kind) throws ParseException { + Token oldToken; + if ((oldToken = token).next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + if (token.kind == kind) { + jj_gen++; + if (++jj_gc > 100) { + jj_gc = 0; + for (int i = 0; i < jj_2_rtns.length; i++) { + JJCalls c = jj_2_rtns[i]; + while (c != null) { + if (c.gen < jj_gen) c.first = null; + c = c.next; + } + } + } + return token; + } + token = oldToken; + jj_kind = kind; + throw generateParseException(); + } + + @SuppressWarnings("serial") + static private final class LookaheadSuccess extends java.lang.RuntimeException { } + final private LookaheadSuccess jj_ls = new LookaheadSuccess(); + private boolean jj_scan_token(int kind) { + if (jj_scanpos == jj_lastpos) { + jj_la--; + if (jj_scanpos.next == null) { + jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); + } else { + jj_lastpos = jj_scanpos = jj_scanpos.next; + } + } else { + jj_scanpos = jj_scanpos.next; + } + if (jj_rescan) { + int i = 0; Token tok = token; + while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } + if (tok != null) jj_add_error_token(kind, i); + } + if (jj_scanpos.kind != kind) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; + return false; + } + + +/** Get the next Token. */ + final public Token getNextToken() { + if (token.next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + jj_gen++; + return token; + } + +/** Get the specific Token. */ + final public Token getToken(int index) { + Token t = jj_lookingAhead ? jj_scanpos : token; + for (int i = 0; i < index; i++) { + if (t.next != null) t = t.next; + else t = t.next = token_source.getNextToken(); + } + return t; + } + + private int jj_ntk_f() { + if ((jj_nt=token.next) == null) + return (jj_ntk = (token.next=token_source.getNextToken()).kind); + else + return (jj_ntk = jj_nt.kind); + } + + private java.util.List jj_expentries = new java.util.ArrayList(); + private int[] jj_expentry; + private int jj_kind = -1; + private int[] jj_lasttokens = new int[100]; + private int jj_endpos; + + private void jj_add_error_token(int kind, int pos) { + if (pos >= 100) { + return; + } + + if (pos == jj_endpos + 1) { + jj_lasttokens[jj_endpos++] = kind; + } else if (jj_endpos != 0) { + jj_expentry = new int[jj_endpos]; + + for (int i = 0; i < jj_endpos; i++) { + jj_expentry[i] = jj_lasttokens[i]; + } + + for (int[] oldentry : jj_expentries) { + if (oldentry.length == jj_expentry.length) { + boolean isMatched = true; + + for (int i = 0; i < jj_expentry.length; i++) { + if (oldentry[i] != jj_expentry[i]) { + isMatched = false; + break; + } + + } + if (isMatched) { + jj_expentries.add(jj_expentry); + break; + } + } + } + + if (pos != 0) { + jj_lasttokens[(jj_endpos = pos) - 1] = kind; + } + } + } + + /** Generate ParseException. */ + public ParseException generateParseException() { + jj_expentries.clear(); + boolean[] la1tokens = new boolean[143]; + if (jj_kind >= 0) { + la1tokens[jj_kind] = true; + jj_kind = -1; + } + for (int i = 0; i < 164; i++) { + if (jj_la1[i] == jj_gen) { + for (int j = 0; j < 32; j++) { + if ((jj_la1_0[i] & (1< jj_gen) { + jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; + switch (i) { + case 0: jj_3_1(); break; + case 1: jj_3_2(); break; + case 2: jj_3_3(); break; + case 3: jj_3_4(); break; + case 4: jj_3_5(); break; + case 5: jj_3_6(); break; + case 6: jj_3_7(); break; + case 7: jj_3_8(); break; + case 8: jj_3_9(); break; + case 9: jj_3_10(); break; + case 10: jj_3_11(); break; + case 11: jj_3_12(); break; + case 12: jj_3_13(); break; + case 13: jj_3_14(); break; + case 14: jj_3_15(); break; + case 15: jj_3_16(); break; + case 16: jj_3_17(); break; + case 17: jj_3_18(); break; + case 18: jj_3_19(); break; + case 19: jj_3_20(); break; + case 20: jj_3_21(); break; + case 21: jj_3_22(); break; + case 22: jj_3_23(); break; + case 23: jj_3_24(); break; + case 24: jj_3_25(); break; + case 25: jj_3_26(); break; + case 26: jj_3_27(); break; + case 27: jj_3_28(); break; + case 28: jj_3_29(); break; + case 29: jj_3_30(); break; + case 30: jj_3_31(); break; + case 31: jj_3_32(); break; + case 32: jj_3_33(); break; + case 33: jj_3_34(); break; + case 34: jj_3_35(); break; + case 35: jj_3_36(); break; + case 36: jj_3_37(); break; + case 37: jj_3_38(); break; + case 38: jj_3_39(); break; + case 39: jj_3_40(); break; + case 40: jj_3_41(); break; + case 41: jj_3_42(); break; + case 42: jj_3_43(); break; + case 43: jj_3_44(); break; + case 44: jj_3_45(); break; + case 45: jj_3_46(); break; + case 46: jj_3_47(); break; + case 47: jj_3_48(); break; + case 48: jj_3_49(); break; + case 49: jj_3_50(); break; + case 50: jj_3_51(); break; + case 51: jj_3_52(); break; + case 52: jj_3_53(); break; + case 53: jj_3_54(); break; + case 54: jj_3_55(); break; + case 55: jj_3_56(); break; + case 56: jj_3_57(); break; + case 57: jj_3_58(); break; + } + } + p = p.next; + } while (p != null); + + } catch(LookaheadSuccess ls) { } + } + jj_rescan = false; + } + + private void jj_save(int index, int xla) { + JJCalls p = jj_2_rtns[index]; + while (p.gen > jj_gen) { + if (p.next == null) { p = p.next = new JJCalls(); break; } + p = p.next; + } + + p.gen = jj_gen + xla - jj_la; + p.first = token; + p.arg = xla; + } + + static final class JJCalls { + int gen; + Token first; + int arg; + JJCalls next; + } + +} diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserConstants.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserConstants.java new file mode 100644 index 000000000..e59d1e3e6 --- /dev/null +++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserConstants.java @@ -0,0 +1,472 @@ +/* Generated By:JavaCC: Do not edit this line. GeneratedJavaParserConstants.java */ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser; + + +/** + * Token literal values and constants. + * Generated by org.javacc.parser.OtherFilesGen#start() + */ +public interface GeneratedJavaParserConstants { + + /** End of File. */ + int EOF = 0; + /** RegularExpression Id. */ + int SPACE = 1; + /** RegularExpression Id. */ + int WINDOWS_EOL = 2; + /** RegularExpression Id. */ + int UNIX_EOL = 3; + /** RegularExpression Id. */ + int OLD_MAC_EOL = 4; + /** RegularExpression Id. */ + int SINGLE_LINE_COMMENT = 5; + /** RegularExpression Id. */ + int ENTER_JAVADOC_COMMENT = 6; + /** RegularExpression Id. */ + int ENTER_MULTILINE_COMMENT = 7; + /** RegularExpression Id. */ + int JAVADOC_COMMENT = 8; + /** RegularExpression Id. */ + int MULTI_LINE_COMMENT = 9; + /** RegularExpression Id. */ + int COMMENT_CONTENT = 10; + /** RegularExpression Id. */ + int ABSTRACT = 11; + /** RegularExpression Id. */ + int ASSERT = 12; + /** RegularExpression Id. */ + int BOOLEAN = 13; + /** RegularExpression Id. */ + int BREAK = 14; + /** RegularExpression Id. */ + int BYTE = 15; + /** RegularExpression Id. */ + int CASE = 16; + /** RegularExpression Id. */ + int CATCH = 17; + /** RegularExpression Id. */ + int CHAR = 18; + /** RegularExpression Id. */ + int CLASS = 19; + /** RegularExpression Id. */ + int CONST = 20; + /** RegularExpression Id. */ + int CONTINUE = 21; + /** RegularExpression Id. */ + int _DEFAULT = 22; + /** RegularExpression Id. */ + int DO = 23; + /** RegularExpression Id. */ + int DOUBLE = 24; + /** RegularExpression Id. */ + int ELSE = 25; + /** RegularExpression Id. */ + int ENUM = 26; + /** RegularExpression Id. */ + int EXTENDS = 27; + /** RegularExpression Id. */ + int FALSE = 28; + /** RegularExpression Id. */ + int FINAL = 29; + /** RegularExpression Id. */ + int FINALLY = 30; + /** RegularExpression Id. */ + int FLOAT = 31; + /** RegularExpression Id. */ + int FOR = 32; + /** RegularExpression Id. */ + int GOTO = 33; + /** RegularExpression Id. */ + int IF = 34; + /** RegularExpression Id. */ + int IMPLEMENTS = 35; + /** RegularExpression Id. */ + int IMPORT = 36; + /** RegularExpression Id. */ + int INSTANCEOF = 37; + /** RegularExpression Id. */ + int INT = 38; + /** RegularExpression Id. */ + int INTERFACE = 39; + /** RegularExpression Id. */ + int LONG = 40; + /** RegularExpression Id. */ + int NATIVE = 41; + /** RegularExpression Id. */ + int NEW = 42; + /** RegularExpression Id. */ + int NULL = 43; + /** RegularExpression Id. */ + int PACKAGE = 44; + /** RegularExpression Id. */ + int PRIVATE = 45; + /** RegularExpression Id. */ + int PROTECTED = 46; + /** RegularExpression Id. */ + int PUBLIC = 47; + /** RegularExpression Id. */ + int RETURN = 48; + /** RegularExpression Id. */ + int SHORT = 49; + /** RegularExpression Id. */ + int STATIC = 50; + /** RegularExpression Id. */ + int STRICTFP = 51; + /** RegularExpression Id. */ + int SUPER = 52; + /** RegularExpression Id. */ + int SWITCH = 53; + /** RegularExpression Id. */ + int SYNCHRONIZED = 54; + /** RegularExpression Id. */ + int THIS = 55; + /** RegularExpression Id. */ + int THROW = 56; + /** RegularExpression Id. */ + int THROWS = 57; + /** RegularExpression Id. */ + int TRANSIENT = 58; + /** RegularExpression Id. */ + int TRUE = 59; + /** RegularExpression Id. */ + int TRY = 60; + /** RegularExpression Id. */ + int VOID = 61; + /** RegularExpression Id. */ + int VOLATILE = 62; + /** RegularExpression Id. */ + int WHILE = 63; + /** RegularExpression Id. */ + int REQUIRES = 64; + /** RegularExpression Id. */ + int TO = 65; + /** RegularExpression Id. */ + int WITH = 66; + /** RegularExpression Id. */ + int OPEN = 67; + /** RegularExpression Id. */ + int OPENS = 68; + /** RegularExpression Id. */ + int USES = 69; + /** RegularExpression Id. */ + int MODULE = 70; + /** RegularExpression Id. */ + int EXPORTS = 71; + /** RegularExpression Id. */ + int PROVIDES = 72; + /** RegularExpression Id. */ + int TRANSITIVE = 73; + /** RegularExpression Id. */ + int LONG_LITERAL = 74; + /** RegularExpression Id. */ + int INTEGER_LITERAL = 75; + /** RegularExpression Id. */ + int DECIMAL_LITERAL = 76; + /** RegularExpression Id. */ + int HEX_LITERAL = 77; + /** RegularExpression Id. */ + int OCTAL_LITERAL = 78; + /** RegularExpression Id. */ + int BINARY_LITERAL = 79; + /** RegularExpression Id. */ + int FLOATING_POINT_LITERAL = 80; + /** RegularExpression Id. */ + int DECIMAL_FLOATING_POINT_LITERAL = 81; + /** RegularExpression Id. */ + int DECIMAL_EXPONENT = 82; + /** RegularExpression Id. */ + int HEXADECIMAL_FLOATING_POINT_LITERAL = 83; + /** RegularExpression Id. */ + int HEXADECIMAL_EXPONENT = 84; + /** RegularExpression Id. */ + int HEX_DIGITS = 85; + /** RegularExpression Id. */ + int UNICODE_ESCAPE = 86; + /** RegularExpression Id. */ + int CHARACTER_LITERAL = 87; + /** RegularExpression Id. */ + int STRING_LITERAL = 88; + /** RegularExpression Id. */ + int IDENTIFIER = 89; + /** RegularExpression Id. */ + int LETTER = 90; + /** RegularExpression Id. */ + int PART_LETTER = 91; + /** RegularExpression Id. */ + int LPAREN = 92; + /** RegularExpression Id. */ + int RPAREN = 93; + /** RegularExpression Id. */ + int LBRACE = 94; + /** RegularExpression Id. */ + int RBRACE = 95; + /** RegularExpression Id. */ + int LBRACKET = 96; + /** RegularExpression Id. */ + int RBRACKET = 97; + /** RegularExpression Id. */ + int SEMICOLON = 98; + /** RegularExpression Id. */ + int COMMA = 99; + /** RegularExpression Id. */ + int DOT = 100; + /** RegularExpression Id. */ + int AT = 101; + /** RegularExpression Id. */ + int ASSIGN = 102; + /** RegularExpression Id. */ + int LT = 103; + /** RegularExpression Id. */ + int BANG = 104; + /** RegularExpression Id. */ + int TILDE = 105; + /** RegularExpression Id. */ + int HOOK = 106; + /** RegularExpression Id. */ + int COLON = 107; + /** RegularExpression Id. */ + int EQ = 108; + /** RegularExpression Id. */ + int LE = 109; + /** RegularExpression Id. */ + int GE = 110; + /** RegularExpression Id. */ + int NE = 111; + /** RegularExpression Id. */ + int SC_OR = 112; + /** RegularExpression Id. */ + int SC_AND = 113; + /** RegularExpression Id. */ + int INCR = 114; + /** RegularExpression Id. */ + int DECR = 115; + /** RegularExpression Id. */ + int PLUS = 116; + /** RegularExpression Id. */ + int MINUS = 117; + /** RegularExpression Id. */ + int STAR = 118; + /** RegularExpression Id. */ + int SLASH = 119; + /** RegularExpression Id. */ + int BIT_AND = 120; + /** RegularExpression Id. */ + int BIT_OR = 121; + /** RegularExpression Id. */ + int XOR = 122; + /** RegularExpression Id. */ + int REM = 123; + /** RegularExpression Id. */ + int LSHIFT = 124; + /** RegularExpression Id. */ + int PLUSASSIGN = 125; + /** RegularExpression Id. */ + int MINUSASSIGN = 126; + /** RegularExpression Id. */ + int STARASSIGN = 127; + /** RegularExpression Id. */ + int SLASHASSIGN = 128; + /** RegularExpression Id. */ + int ANDASSIGN = 129; + /** RegularExpression Id. */ + int ORASSIGN = 130; + /** RegularExpression Id. */ + int XORASSIGN = 131; + /** RegularExpression Id. */ + int REMASSIGN = 132; + /** RegularExpression Id. */ + int LSHIFTASSIGN = 133; + /** RegularExpression Id. */ + int RSIGNEDSHIFTASSIGN = 134; + /** RegularExpression Id. */ + int RUNSIGNEDSHIFTASSIGN = 135; + /** RegularExpression Id. */ + int ELLIPSIS = 136; + /** RegularExpression Id. */ + int ARROW = 137; + /** RegularExpression Id. */ + int DOUBLECOLON = 138; + /** RegularExpression Id. */ + int RUNSIGNEDSHIFT = 139; + /** RegularExpression Id. */ + int RSIGNEDSHIFT = 140; + /** RegularExpression Id. */ + int GT = 141; + /** RegularExpression Id. */ + int CTRL_Z = 142; + + /** Lexical state. */ + int DEFAULT = 0; + /** Lexical state. */ + int IN_JAVADOC_COMMENT = 1; + /** Lexical state. */ + int IN_MULTI_LINE_COMMENT = 2; + + /** Literal token values. */ + String[] tokenImage = { + "", + "", + "\"\\r\\n\"", + "\"\\n\"", + "\"\\r\"", + "", + "", + "\"/*\"", + "\"*/\"", + "\"*/\"", + "", + "\"abstract\"", + "\"assert\"", + "\"boolean\"", + "\"break\"", + "\"byte\"", + "\"case\"", + "\"catch\"", + "\"char\"", + "\"class\"", + "\"const\"", + "\"continue\"", + "\"default\"", + "\"do\"", + "\"double\"", + "\"else\"", + "\"enum\"", + "\"extends\"", + "\"false\"", + "\"final\"", + "\"finally\"", + "\"float\"", + "\"for\"", + "\"goto\"", + "\"if\"", + "\"implements\"", + "\"import\"", + "\"instanceof\"", + "\"int\"", + "\"interface\"", + "\"long\"", + "\"native\"", + "\"new\"", + "\"null\"", + "\"package\"", + "\"private\"", + "\"protected\"", + "\"public\"", + "\"return\"", + "\"short\"", + "\"static\"", + "\"strictfp\"", + "\"super\"", + "\"switch\"", + "\"synchronized\"", + "\"this\"", + "\"throw\"", + "\"throws\"", + "\"transient\"", + "\"true\"", + "\"try\"", + "\"void\"", + "\"volatile\"", + "\"while\"", + "\"requires\"", + "\"to\"", + "\"with\"", + "\"open\"", + "\"opens\"", + "\"uses\"", + "\"module\"", + "\"exports\"", + "\"provides\"", + "\"transitive\"", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\"(\"", + "\")\"", + "\"{\"", + "\"}\"", + "\"[\"", + "\"]\"", + "\";\"", + "\",\"", + "\".\"", + "\"@\"", + "\"=\"", + "\"<\"", + "\"!\"", + "\"~\"", + "\"?\"", + "\":\"", + "\"==\"", + "\"<=\"", + "\">=\"", + "\"!=\"", + "\"||\"", + "\"&&\"", + "\"++\"", + "\"--\"", + "\"+\"", + "\"-\"", + "\"*\"", + "\"/\"", + "\"&\"", + "\"|\"", + "\"^\"", + "\"%\"", + "\"<<\"", + "\"+=\"", + "\"-=\"", + "\"*=\"", + "\"/=\"", + "\"&=\"", + "\"|=\"", + "\"^=\"", + "\"%=\"", + "\"<<=\"", + "\">>=\"", + "\">>>=\"", + "\"...\"", + "\"->\"", + "\"::\"", + "\">>>\"", + "\">>\"", + "\">\"", + "\"\\u001a\"", + }; + +} diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserTokenManager.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserTokenManager.java new file mode 100644 index 000000000..93f340897 --- /dev/null +++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserTokenManager.java @@ -0,0 +1,2966 @@ +/* GeneratedJavaParserTokenManager.java */ +/* Generated By:JavaCC: Do not edit this line. GeneratedJavaParserTokenManager.java */ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser; +import java.io.*; +import java.util.*; +import com.github.javaparser.ast.*; +import com.github.javaparser.ast.body.*; +import com.github.javaparser.ast.comments.*; +import com.github.javaparser.ast.modules.*; +import com.github.javaparser.ast.expr.*; +import com.github.javaparser.ast.stmt.*; +import com.github.javaparser.ast.type.*; +import com.github.javaparser.utils.*; +import javax.annotation.Generated; +import static com.github.javaparser.JavaToken.INVALID; +import static com.github.javaparser.ast.Node.Parsedness.UNPARSABLE; +import static com.github.javaparser.utils.Utils.*; +import static com.github.javaparser.ast.NodeList.*; +import static com.github.javaparser.GeneratedJavaParser.*; +import static com.github.javaparser.Range.*; +import static com.github.javaparser.Position.*; +import static com.github.javaparser.ast.type.ArrayType.*; +import static com.github.javaparser.GeneratedJavaParserTokenManagerBase.*; + +/** Token Manager. */ +public class GeneratedJavaParserTokenManager implements GeneratedJavaParserConstants { + private List tokens = new ArrayList(); + private CommentsCollection commentsCollection = new CommentsCollection(); + private JavaToken homeToken; + private Stack tokenWorkStack = new Stack(); + private boolean storeTokens; + + void reset() { + tokens = new ArrayList(); + commentsCollection = new CommentsCollection(); + homeToken = null; + } + + List getTokens() { + if(storeTokens) { + return tokens; + } + return null; + } + + CommentsCollection getCommentsCollection() { + return commentsCollection; + } + + /* Get the very first token in the file */ + JavaToken getHomeToken() { + return homeToken; + } + + /* Makes the parser keep a list of tokens */ + public void setStoreTokens(boolean storeTokens) { + this.storeTokens = storeTokens; + } + + private void CommonTokenAction(Token token) { + // Use an intermediary stack to avoid recursion, see issue 1003 + do { + tokenWorkStack.push(token); + token = token.specialToken; + } while (token != null); + + // The stack is now filled with tokens in left-to-right order. Process them. + while(!tokenWorkStack.empty()) { + token = tokenWorkStack.pop(); + token.javaToken = new JavaToken(token, tokens); + + if(storeTokens) { + tokens.add(token.javaToken); + } + + if (homeToken == null) { + homeToken = token.javaToken; + } + + if(TokenTypes.isComment(token.kind)) { + Comment comment = createCommentFromToken(token); + commentsCollection.addComment(comment); + } + } + } + + /** Debug output. */ + public java.io.PrintStream debugStream = System.out; + /** Set debug output. */ + public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } +private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2){ + switch (pos) + { + case 0: + if ((active1 & 0x1000000000L) != 0L || (active2 & 0x100L) != 0L) + return 2; + if ((active0 & 0xfffffffffffff800L) != 0L || (active1 & 0x3ffL) != 0L) + { + jjmatchedKind = 89; + return 144; + } + if ((active0 & 0x80L) != 0L || (active1 & 0x80000000000000L) != 0L || (active2 & 0x1L) != 0L) + return 56; + return -1; + case 1: + if ((active0 & 0x80L) != 0L) + return 61; + if ((active0 & 0xfffffffbfe7ff800L) != 0L || (active1 & 0x3fdL) != 0L) + { + if (jjmatchedPos != 1) + { + jjmatchedKind = 89; + jjmatchedPos = 1; + } + return 144; + } + if ((active0 & 0x401800000L) != 0L || (active1 & 0x2L) != 0L) + return 144; + return -1; + case 2: + if ((active0 & 0x100004c100000000L) != 0L) + return 144; + if ((active0 & 0xeffffb3aff7ff800L) != 0L || (active1 & 0x3fdL) != 0L) + { + if (jjmatchedPos != 2) + { + jjmatchedKind = 89; + jjmatchedPos = 2; + } + return 144; + } + return -1; + case 3: + if ((active0 & 0x2880090206058000L) != 0L || (active1 & 0x3cL) != 0L) + return 144; + if ((active0 & 0xc77ff2b8f97a7800L) != 0L || (active1 & 0x3c1L) != 0L) + { + if (jjmatchedPos != 3) + { + jjmatchedKind = 89; + jjmatchedPos = 3; + } + return 144; + } + return -1; + case 4: + if ((active0 & 0x446df2b809603800L) != 0L || (active1 & 0x3c1L) != 0L) + { + if (jjmatchedPos != 4) + { + jjmatchedKind = 89; + jjmatchedPos = 4; + } + return 144; + } + if ((active0 & 0x83120000f01a4000L) != 0L || (active1 & 0x10L) != 0L) + return 144; + return -1; + case 5: + if ((active0 & 0x225821001001000L) != 0L || (active1 & 0x40L) != 0L) + return 144; + if ((active0 & 0x444870a848602800L) != 0L || (active1 & 0x381L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 5; + return 144; + } + return -1; + case 6: + if ((active0 & 0x300048402000L) != 0L || (active1 & 0x80L) != 0L) + return 144; + if ((active0 & 0x444840a800200800L) != 0L || (active1 & 0x301L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 6; + return 144; + } + return -1; + case 7: + if ((active0 & 0x44040a800000000L) != 0L || (active1 & 0x200L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 7; + return 144; + } + if ((active0 & 0x4008000000200800L) != 0L || (active1 & 0x101L) != 0L) + return 144; + return -1; + case 8: + if ((active0 & 0x400408000000000L) != 0L) + return 144; + if ((active0 & 0x40002800000000L) != 0L || (active1 & 0x200L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 8; + return 144; + } + return -1; + case 9: + if ((active0 & 0x2800000000L) != 0L || (active1 & 0x200L) != 0L) + return 144; + if ((active0 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 9; + return 144; + } + return -1; + case 10: + if ((active0 & 0x40000000000000L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 10; + return 144; + } + return -1; + default : + return -1; + } +} +private final int jjStartNfa_0(int pos, long active0, long active1, long active2){ + return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1); +} +private int jjStopAtPos(int pos, int kind) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + return pos + 1; +} +private int jjMoveStringLiteralDfa0_0(){ + switch(curChar) + { + case 10: + return jjStopAtPos(0, 3); + case 13: + jjmatchedKind = 4; + return jjMoveStringLiteralDfa1_0(0x4L, 0x0L, 0x0L); + case 26: + return jjStopAtPos(0, 142); + case 33: + jjmatchedKind = 104; + return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000L, 0x0L); + case 37: + jjmatchedKind = 123; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x10L); + case 38: + jjmatchedKind = 120; + return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L, 0x2L); + case 40: + return jjStopAtPos(0, 92); + case 41: + return jjStopAtPos(0, 93); + case 42: + jjmatchedKind = 118; + return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000000L, 0x0L); + case 43: + jjmatchedKind = 116; + return jjMoveStringLiteralDfa1_0(0x0L, 0x2004000000000000L, 0x0L); + case 44: + return jjStopAtPos(0, 99); + case 45: + jjmatchedKind = 117; + return jjMoveStringLiteralDfa1_0(0x0L, 0x4008000000000000L, 0x200L); + case 46: + jjmatchedKind = 100; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x100L); + case 47: + jjmatchedKind = 119; + return jjMoveStringLiteralDfa1_0(0x80L, 0x0L, 0x1L); + case 58: + jjmatchedKind = 107; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x400L); + case 59: + return jjStopAtPos(0, 98); + case 60: + jjmatchedKind = 103; + return jjMoveStringLiteralDfa1_0(0x0L, 0x1000200000000000L, 0x20L); + case 61: + jjmatchedKind = 102; + return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000L, 0x0L); + case 62: + jjmatchedKind = 141; + return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000000L, 0x18c0L); + case 63: + return jjStopAtPos(0, 106); + case 64: + return jjStopAtPos(0, 101); + case 91: + return jjStopAtPos(0, 96); + case 93: + return jjStopAtPos(0, 97); + case 94: + jjmatchedKind = 122; + return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x8L); + case 97: + return jjMoveStringLiteralDfa1_0(0x1800L, 0x0L, 0x0L); + case 98: + return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L, 0x0L); + case 99: + return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L, 0x0L); + case 100: + return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L, 0x0L); + case 101: + return jjMoveStringLiteralDfa1_0(0xe000000L, 0x80L, 0x0L); + case 102: + return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L, 0x0L); + case 103: + return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L, 0x0L); + case 105: + return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x0L, 0x0L); + case 108: + return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L, 0x0L); + case 109: + return jjMoveStringLiteralDfa1_0(0x0L, 0x40L, 0x0L); + case 110: + return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L, 0x0L); + case 111: + return jjMoveStringLiteralDfa1_0(0x0L, 0x18L, 0x0L); + case 112: + return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x100L, 0x0L); + case 114: + return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x1L, 0x0L); + case 115: + return jjMoveStringLiteralDfa1_0(0x7e000000000000L, 0x0L, 0x0L); + case 116: + return jjMoveStringLiteralDfa1_0(0x1f80000000000000L, 0x202L, 0x0L); + case 117: + return jjMoveStringLiteralDfa1_0(0x0L, 0x20L, 0x0L); + case 118: + return jjMoveStringLiteralDfa1_0(0x6000000000000000L, 0x0L, 0x0L); + case 119: + return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x4L, 0x0L); + case 123: + return jjStopAtPos(0, 94); + case 124: + jjmatchedKind = 121; + return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000L, 0x4L); + case 125: + return jjStopAtPos(0, 95); + case 126: + return jjStopAtPos(0, 105); + default : + return jjMoveNfa_0(0, 0); + } +} +private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2){ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(0, active0, active1, active2); + return 1; + } + switch(curChar) + { + case 10: + if ((active0 & 0x4L) != 0L) + return jjStopAtPos(1, 2); + break; + case 38: + if ((active1 & 0x2000000000000L) != 0L) + return jjStopAtPos(1, 113); + break; + case 42: + if ((active0 & 0x80L) != 0L) + return jjStartNfaWithStates_0(1, 7, 61); + break; + case 43: + if ((active1 & 0x4000000000000L) != 0L) + return jjStopAtPos(1, 114); + break; + case 45: + if ((active1 & 0x8000000000000L) != 0L) + return jjStopAtPos(1, 115); + break; + case 46: + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x100L); + case 58: + if ((active2 & 0x400L) != 0L) + return jjStopAtPos(1, 138); + break; + case 60: + if ((active1 & 0x1000000000000000L) != 0L) + { + jjmatchedKind = 124; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x20L); + case 61: + if ((active1 & 0x100000000000L) != 0L) + return jjStopAtPos(1, 108); + else if ((active1 & 0x200000000000L) != 0L) + return jjStopAtPos(1, 109); + else if ((active1 & 0x400000000000L) != 0L) + return jjStopAtPos(1, 110); + else if ((active1 & 0x800000000000L) != 0L) + return jjStopAtPos(1, 111); + else if ((active1 & 0x2000000000000000L) != 0L) + return jjStopAtPos(1, 125); + else if ((active1 & 0x4000000000000000L) != 0L) + return jjStopAtPos(1, 126); + else if ((active1 & 0x8000000000000000L) != 0L) + return jjStopAtPos(1, 127); + else if ((active2 & 0x1L) != 0L) + return jjStopAtPos(1, 128); + else if ((active2 & 0x2L) != 0L) + return jjStopAtPos(1, 129); + else if ((active2 & 0x4L) != 0L) + return jjStopAtPos(1, 130); + else if ((active2 & 0x8L) != 0L) + return jjStopAtPos(1, 131); + else if ((active2 & 0x10L) != 0L) + return jjStopAtPos(1, 132); + break; + case 62: + if ((active2 & 0x200L) != 0L) + return jjStopAtPos(1, 137); + else if ((active2 & 0x1000L) != 0L) + { + jjmatchedKind = 140; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x8c0L); + case 97: + return jjMoveStringLiteralDfa2_0(active0, 0x120010030000L, active1, 0L, active2, 0L); + case 98: + return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0L, active2, 0L); + case 101: + return jjMoveStringLiteralDfa2_0(active0, 0x1040000400000L, active1, 0x1L, active2, 0L); + case 102: + if ((active0 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(1, 34, 144); + break; + case 104: + return jjMoveStringLiteralDfa2_0(active0, 0x8382000000040000L, active1, 0L, active2, 0L); + case 105: + return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0x4L, active2, 0L); + case 108: + return jjMoveStringLiteralDfa2_0(active0, 0x82080000L, active1, 0L, active2, 0L); + case 109: + return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0L, active2, 0L); + case 110: + return jjMoveStringLiteralDfa2_0(active0, 0xe004000000L, active1, 0L, active2, 0L); + case 111: + if ((active0 & 0x800000L) != 0L) + { + jjmatchedKind = 23; + jjmatchedPos = 1; + } + else if ((active1 & 0x2L) != 0L) + return jjStartNfaWithStates_0(1, 65, 144); + return jjMoveStringLiteralDfa2_0(active0, 0x6000010301302000L, active1, 0x40L, active2, 0L); + case 112: + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x18L, active2, 0L); + case 114: + return jjMoveStringLiteralDfa2_0(active0, 0x1c00600000004000L, active1, 0x300L, active2, 0L); + case 115: + return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0x20L, active2, 0L); + case 116: + return jjMoveStringLiteralDfa2_0(active0, 0xc000000000000L, active1, 0L, active2, 0L); + case 117: + return jjMoveStringLiteralDfa2_0(active0, 0x10880000000000L, active1, 0L, active2, 0L); + case 119: + return jjMoveStringLiteralDfa2_0(active0, 0x20000000000000L, active1, 0L, active2, 0L); + case 120: + return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0x80L, active2, 0L); + case 121: + return jjMoveStringLiteralDfa2_0(active0, 0x40000000008000L, active1, 0L, active2, 0L); + case 124: + if ((active1 & 0x1000000000000L) != 0L) + return jjStopAtPos(1, 112); + break; + default : + break; + } + return jjStartNfa_0(0, active0, active1, active2); +} +private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1, long old2, long active2){ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L) + return jjStartNfa_0(0, old0, old1, old2); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(1, active0, active1, active2); + return 2; + } + switch(curChar) + { + case 46: + if ((active2 & 0x100L) != 0L) + return jjStopAtPos(2, 136); + break; + case 61: + if ((active2 & 0x20L) != 0L) + return jjStopAtPos(2, 133); + else if ((active2 & 0x40L) != 0L) + return jjStopAtPos(2, 134); + break; + case 62: + if ((active2 & 0x800L) != 0L) + { + jjmatchedKind = 139; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0x80L); + case 97: + return jjMoveStringLiteralDfa3_0(active0, 0x4040000000c0000L, active1, 0x200L, active2, 0L); + case 98: + return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0L, active2, 0L); + case 99: + return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L, active2, 0L); + case 100: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x40L, active2, 0L); + case 101: + return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1, 0x38L, active2, 0L); + case 102: + return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0L, active2, 0L); + case 105: + return jjMoveStringLiteralDfa3_0(active0, 0xa0a0200000000000L, active1, 0L, active2, 0L); + case 108: + return jjMoveStringLiteralDfa3_0(active0, 0x4000080010000000L, active1, 0L, active2, 0L); + case 110: + return jjMoveStringLiteralDfa3_0(active0, 0x40010060300000L, active1, 0L, active2, 0L); + case 111: + return jjMoveStringLiteralDfa3_0(active0, 0x2400080002000L, active1, 0x100L, active2, 0L); + case 112: + return jjMoveStringLiteralDfa3_0(active0, 0x10001800000000L, active1, 0x80L, active2, 0L); + case 113: + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1L, active2, 0L); + case 114: + if ((active0 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(2, 32, 144); + return jjMoveStringLiteralDfa3_0(active0, 0x308000000000000L, active1, 0L, active2, 0L); + case 115: + return jjMoveStringLiteralDfa3_0(active0, 0x2002011800L, active1, 0L, active2, 0L); + case 116: + if ((active0 & 0x4000000000L) != 0L) + { + jjmatchedKind = 38; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x1028208028000L, active1, 0x4L, active2, 0L); + case 117: + return jjMoveStringLiteralDfa3_0(active0, 0x800000005000000L, active1, 0L, active2, 0L); + case 119: + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(2, 42, 144); + break; + case 121: + if ((active0 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 60, 144); + break; + default : + break; + } + return jjStartNfa_0(1, active0, active1, active2); +} +private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1, long old2, long active2){ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L) + return jjStartNfa_0(1, old0, old1, old2); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(2, active0, active1, active2); + return 3; + } + switch(curChar) + { + case 61: + if ((active2 & 0x80L) != 0L) + return jjStopAtPos(3, 135); + break; + case 97: + return jjMoveStringLiteralDfa4_0(active0, 0x40000000e0404000L, active1, 0L, active2, 0L); + case 98: + return jjMoveStringLiteralDfa4_0(active0, 0x1000000L, active1, 0L, active2, 0L); + case 99: + return jjMoveStringLiteralDfa4_0(active0, 0x40000000020000L, active1, 0L, active2, 0L); + case 100: + if ((active0 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 61, 144); + break; + case 101: + if ((active0 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(3, 15, 144); + else if ((active0 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(3, 16, 144); + else if ((active0 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(3, 25, 144); + else if ((active0 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 59, 144); + return jjMoveStringLiteralDfa4_0(active0, 0x10008008001000L, active1, 0L, active2, 0L); + case 103: + if ((active0 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(3, 40, 144); + break; + case 104: + if ((active1 & 0x4L) != 0L) + return jjStartNfaWithStates_0(3, 66, 144); + break; + case 105: + return jjMoveStringLiteralDfa4_0(active0, 0x8020000000000L, active1, 0L, active2, 0L); + case 107: + return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L, active2, 0L); + case 108: + if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(3, 43, 144); + return jjMoveStringLiteralDfa4_0(active0, 0x8000800800002000L, active1, 0L, active2, 0L); + case 109: + if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(3, 26, 144); + break; + case 110: + if ((active1 & 0x8L) != 0L) + { + jjmatchedKind = 67; + jjmatchedPos = 3; + } + return jjMoveStringLiteralDfa4_0(active0, 0x400000000000000L, active1, 0x210L, active2, 0L); + case 111: + if ((active0 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(3, 33, 144); + return jjMoveStringLiteralDfa4_0(active0, 0x300001000000000L, active1, 0x80L, active2, 0L); + case 114: + if ((active0 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(3, 18, 144); + return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L, active2, 0L); + case 115: + if ((active0 & 0x80000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 55, 144); + else if ((active1 & 0x20L) != 0L) + return jjStartNfaWithStates_0(3, 69, 144); + return jjMoveStringLiteralDfa4_0(active0, 0x10180000L, active1, 0L, active2, 0L); + case 116: + return jjMoveStringLiteralDfa4_0(active0, 0x24402000200800L, active1, 0L, active2, 0L); + case 117: + return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0x41L, active2, 0L); + case 118: + return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0x100L, active2, 0L); + default : + break; + } + return jjStartNfa_0(2, active0, active1, active2); +} +private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1, long old2, long active2){ + if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L) + return jjStartNfa_0(2, old0, old1, old2); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(3, active0, active1, 0L); + return 4; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa5_0(active0, 0x28000000000000L, active1, 0L); + case 101: + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(4, 28, 144); + else if ((active0 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 63, 144); + return jjMoveStringLiteralDfa5_0(active0, 0x400800002000L, active1, 0L); + case 104: + if ((active0 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(4, 17, 144); + return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa5_0(active0, 0x4800000200000L, active1, 0x101L); + case 107: + if ((active0 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(4, 14, 144); + break; + case 108: + if ((active0 & 0x20000000L) != 0L) + { + jjmatchedKind = 29; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0x41000000L, active1, 0x40L); + case 110: + return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0L); + case 114: + if ((active0 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 52, 144); + return jjMoveStringLiteralDfa5_0(active0, 0x1009000001800L, active1, 0x80L); + case 115: + if ((active0 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(4, 19, 144); + else if ((active1 & 0x10L) != 0L) + return jjStartNfaWithStates_0(4, 68, 144); + return jjMoveStringLiteralDfa5_0(active0, 0x400000000000000L, active1, 0x200L); + case 116: + if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(4, 20, 144); + else if ((active0 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(4, 31, 144); + else if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 49, 144); + return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa5_0(active0, 0x400000L, active1, 0L); + case 118: + return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L, active1, 0L); + case 119: + if ((active0 & 0x100000000000000L) != 0L) + { + jjmatchedKind = 56; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(3, active0, active1, 0L); +} +private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1){ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(3, old0, old1, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(4, active0, active1, 0L); + return 5; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa6_0(active0, 0x2800L, active1, 0L); + case 99: + if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(5, 47, 144); + else if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 50, 144); + return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L); + case 100: + return jjMoveStringLiteralDfa6_0(active0, 0x8000000L, active1, 0x100L); + case 101: + if ((active0 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(5, 24, 144); + else if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(5, 41, 144); + else if ((active1 & 0x40L) != 0L) + return jjStartNfaWithStates_0(5, 70, 144); + break; + case 102: + return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L); + case 103: + return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0L); + case 104: + if ((active0 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 53, 144); + break; + case 105: + return jjMoveStringLiteralDfa6_0(active0, 0x4400000000000000L, active1, 0x200L); + case 108: + return jjMoveStringLiteralDfa6_0(active0, 0x40400000L, active1, 0L); + case 109: + return jjMoveStringLiteralDfa6_0(active0, 0x800000000L, active1, 0L); + case 110: + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 48, 144); + return jjMoveStringLiteralDfa6_0(active0, 0x2000200000L, active1, 0L); + case 114: + return jjMoveStringLiteralDfa6_0(active0, 0x40000000000000L, active1, 0x1L); + case 115: + if ((active0 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 57, 144); + break; + case 116: + if ((active0 & 0x1000L) != 0L) + return jjStartNfaWithStates_0(5, 12, 144); + else if ((active0 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(5, 36, 144); + return jjMoveStringLiteralDfa6_0(active0, 0x8200000000000L, active1, 0x80L); + default : + break; + } + return jjStartNfa_0(4, active0, active1, 0L); +} +private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1){ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(4, old0, old1, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(5, active0, active1, 0L); + return 6; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa7_0(active0, 0x2000000800L, active1, 0L); + case 101: + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(6, 44, 144); + else if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(6, 45, 144); + return jjMoveStringLiteralDfa7_0(active0, 0x400000800000000L, active1, 0x101L); + case 102: + return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000000L, active1, 0L); + case 110: + if ((active0 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(6, 13, 144); + break; + case 111: + return jjMoveStringLiteralDfa7_0(active0, 0x40000000000000L, active1, 0L); + case 115: + if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(6, 27, 144); + else if ((active1 & 0x80L) != 0L) + return jjStartNfaWithStates_0(6, 71, 144); + break; + case 116: + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(6, 22, 144); + return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L, active1, 0x200L); + case 117: + return jjMoveStringLiteralDfa7_0(active0, 0x200000L, active1, 0L); + case 121: + if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(6, 30, 144); + break; + default : + break; + } + return jjStartNfa_0(5, active0, active1, 0L); +} +private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1){ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(5, old0, old1, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(6, active0, active1, 0L); + return 7; + } + switch(curChar) + { + case 99: + return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L, active1, 0L); + case 101: + if ((active0 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(7, 21, 144); + else if ((active0 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 62, 144); + return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x200L); + case 110: + return jjMoveStringLiteralDfa8_0(active0, 0x440000800000000L, active1, 0L); + case 112: + if ((active0 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 51, 144); + break; + case 115: + if ((active1 & 0x1L) != 0L) + return jjStartNfaWithStates_0(7, 64, 144); + else if ((active1 & 0x100L) != 0L) + return jjStartNfaWithStates_0(7, 72, 144); + break; + case 116: + if ((active0 & 0x800L) != 0L) + return jjStartNfaWithStates_0(7, 11, 144); + break; + default : + break; + } + return jjStartNfa_0(6, active0, active1, 0L); +} +private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1){ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(6, old0, old1, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(7, active0, active1, 0L); + return 8; + } + switch(curChar) + { + case 100: + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(8, 46, 144); + break; + case 101: + if ((active0 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(8, 39, 144); + break; + case 105: + return jjMoveStringLiteralDfa9_0(active0, 0x40000000000000L, active1, 0L); + case 111: + return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L, active1, 0L); + case 116: + if ((active0 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 58, 144); + return jjMoveStringLiteralDfa9_0(active0, 0x800000000L, active1, 0L); + case 118: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x200L); + default : + break; + } + return jjStartNfa_0(7, active0, active1, 0L); +} +private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1){ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(7, old0, old1, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(8, active0, active1, 0L); + return 9; + } + switch(curChar) + { + case 101: + if ((active1 & 0x200L) != 0L) + return jjStartNfaWithStates_0(9, 73, 144); + break; + case 102: + if ((active0 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(9, 37, 144); + break; + case 115: + if ((active0 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(9, 35, 144); + break; + case 122: + return jjMoveStringLiteralDfa10_0(active0, 0x40000000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(8, active0, active1, 0L); +} +private int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1){ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(8, old0, old1, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(9, active0, 0L, 0L); + return 10; + } + switch(curChar) + { + case 101: + return jjMoveStringLiteralDfa11_0(active0, 0x40000000000000L); + default : + break; + } + return jjStartNfa_0(9, active0, 0L, 0L); +} +private int jjMoveStringLiteralDfa11_0(long old0, long active0){ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(9, old0, 0L, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(10, active0, 0L, 0L); + return 11; + } + switch(curChar) + { + case 100: + if ((active0 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 54, 144); + break; + default : + break; + } + return jjStartNfa_0(10, active0, 0L, 0L); +} +private int jjStartNfaWithStates_0(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_0(state, pos + 1); +} +static final long[] jjbitVec0 = { + 0x0L, 0x0L, 0x100000020L, 0x0L +}; +static final long[] jjbitVec1 = { + 0x0L, 0x0L, 0x1L, 0x0L +}; +static final long[] jjbitVec2 = { + 0x4000L, 0x0L, 0x0L, 0x0L +}; +static final long[] jjbitVec3 = { + 0x830000003fffL, 0x180000000L, 0x0L, 0x0L +}; +static final long[] jjbitVec4 = { + 0x1L, 0x0L, 0x0L, 0x0L +}; +static final long[] jjbitVec5 = { + 0x0L, 0x0L, 0x0L, 0x8000000000000000L +}; +static final long[] jjbitVec6 = { + 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec8 = { + 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec9 = { + 0xfff0000040220002L, 0xffffffffffffdfffL, 0xfffff02f7fffffffL, 0x12000000ff7fffffL +}; +static final long[] jjbitVec10 = { + 0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL +}; +static final long[] jjbitVec11 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x501f0003ffc3L +}; +static final long[] jjbitVec12 = { + 0x0L, 0x3cdf000000000000L, 0xfffffffbffffd740L, 0xffbfffffffffffffL +}; +static final long[] jjbitVec13 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffffc03L, 0xffffffffffffffffL +}; +static final long[] jjbitVec14 = { + 0xfffe00ffffffffffL, 0xfffffffe027fffffL, 0x80ffL, 0x707ffffff0000L +}; +static final long[] jjbitVec15 = { + 0xffffffff00000800L, 0xfffec000000007ffL, 0xffffffffffffffffL, 0x9c00c060002fffffL +}; +static final long[] jjbitVec16 = { + 0xfffffffd0000L, 0xffffffffffffe000L, 0x2003fffffffffL, 0x43007fffffffc00L +}; +static final long[] jjbitVec17 = { + 0x110043fffffL, 0x1ffffffL, 0x1ffd00000000L, 0x0L +}; +static final long[] jjbitVec18 = { + 0x23fffffffffffff0L, 0xfefe0003ff010000L, 0x23c5fdfffff99fe0L, 0x80f0003b0004000L +}; +static final long[] jjbitVec19 = { + 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbbfe0L, 0x2000300010000L +}; +static final long[] jjbitVec20 = { + 0x23edfdfffff99fe0L, 0x20003b0000000L, 0x3ffc718d63dc7e8L, 0x200000000010000L +}; +static final long[] jjbitVec21 = { + 0x23effdfffffddfe0L, 0x303000000L, 0x23effdfffffddfe0L, 0x6000340000000L +}; +static final long[] jjbitVec22 = { + 0x27fffffffffddfe0L, 0xfc00000300004000L, 0x2ffbfffffc7fffe0L, 0x7fL +}; +static final long[] jjbitVec23 = { + 0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0xf000005fL +}; +static final long[] jjbitVec24 = { + 0x1L, 0x1ffffffffeffL, 0x1f00L, 0x0L +}; +static final long[] jjbitVec25 = { + 0x800007ffffffffffL, 0xffe1c0623c3f0000L, 0xffffffff00004003L, 0xf7ffffffffff20bfL +}; +static final long[] jjbitVec26 = { + 0xffffffffffffffffL, 0xffffffff3d7f3dffL, 0x7f3dffffffff3dffL, 0xffffffffff7fff3dL +}; +static final long[] jjbitVec27 = { + 0xffffffffff3dffffL, 0x7ffffffL, 0xffffffff0000ffffL, 0x1fffffffffffffL +}; +static final long[] jjbitVec28 = { + 0xffffffffffffffffL, 0xffff9fffffffffffL, 0xffffffff07fffffeL, 0x1c7ffffffffffL +}; +static final long[] jjbitVec29 = { + 0x3ffff0003dfffL, 0x1dfff0003ffffL, 0xfffffffffffffL, 0x18800000L +}; +static final long[] jjbitVec30 = { + 0xffffffff00000000L, 0xffffffffffffffL, 0xffff05ffffffffffL, 0x3fffffffffffffL +}; +static final long[] jjbitVec31 = { + 0x1fffffffL, 0x1f3fffffff0000L, 0xfffffffffffL, 0xfeL +}; +static final long[] jjbitVec32 = { + 0xffffffff007fffffL, 0x1fffffL, 0x8000000000L, 0x0L +}; +static final long[] jjbitVec33 = { + 0xfffffffffffe0L, 0xfe0L, 0xfc00c001fffffff8L, 0x3fffffffffL +}; +static final long[] jjbitVec34 = { + 0xfffffffffL, 0x3ffffffffc00e000L, 0x0L, 0x63de0000000000L +}; +static final long[] jjbitVec35 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L +}; +static final long[] jjbitVec36 = { + 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL +}; +static final long[] jjbitVec37 = { + 0x8000000000000000L, 0x8002000000100001L, 0x7ffffff1fff0000L, 0x0L +}; +static final long[] jjbitVec38 = { + 0xf3ffbd503e2ffc84L, 0xffffffff000043e0L, 0x1ffL, 0x0L +}; +static final long[] jjbitVec39 = { + 0xffff7fffffffffffL, 0xffffffff7fffffffL, 0xffffffffffffffffL, 0xc781fffffffffL +}; +static final long[] jjbitVec40 = { + 0xffff20bfffffffffL, 0x80ffffffffffL, 0x7f7f7f7f007fffffL, 0x7f7f7f7fL +}; +static final long[] jjbitVec41 = { + 0x800000000000L, 0x0L, 0x0L, 0x0L +}; +static final long[] jjbitVec42 = { + 0x1f3e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffee07fffffL, 0xf7ffffffffffffffL +}; +static final long[] jjbitVec43 = { + 0xfffe3fffffffffe0L, 0xffffffffffffffffL, 0x7ffffff00007fffL, 0xffff000000000000L +}; +static final long[] jjbitVec44 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L +}; +static final long[] jjbitVec45 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL +}; +static final long[] jjbitVec46 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x3fffffffffff0000L +}; +static final long[] jjbitVec47 = { + 0xc00ffff1fffL, 0x80007fffffffffffL, 0xffffffff00ffffffL, 0xffffffffffffL +}; +static final long[] jjbitVec48 = { + 0xfffffffcff800000L, 0xffffffffffffffffL, 0x7ff000f79ffL, 0xff00000000000000L +}; +static final long[] jjbitVec49 = { + 0x1000007fffff7bbL, 0xfffffffffffffL, 0xffffffffffffcL, 0x8fc000000000000L +}; +static final long[] jjbitVec50 = { + 0xffff003ffffffc00L, 0x1fffffff0000007fL, 0x7fffffffffff0L, 0x8000L +}; +static final long[] jjbitVec51 = { + 0x1ffffffffffL, 0x47fffff00000ff7L, 0x3e62ffffffffffffL, 0x1c07ff38000005L +}; +static final long[] jjbitVec52 = { + 0x7f7f007e7e7eL, 0x0L, 0x0L, 0x7ffffffffL +}; +static final long[] jjbitVec53 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffff000fffffffffL, 0xffffffffffff87fL +}; +static final long[] jjbitVec54 = { + 0xffffffffffffffffL, 0xffff3fffffffffffL, 0xffffffffffffffffL, 0x3ffffffL +}; +static final long[] jjbitVec55 = { + 0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L +}; +static final long[] jjbitVec56 = { + 0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0x1fff0000000000ffL +}; +static final long[] jjbitVec57 = { + 0x18000000000000L, 0xffdf02000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL +}; +static final long[] jjbitVec58 = { + 0x87fffffe00000010L, 0xffffffc007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL +}; +static final long[] jjbitVec59 = { + 0x0L, 0x0L, 0x420243cffffffffL, 0xff7fffffff7fffffL +}; +static final long[] jjbitVec60 = { + 0xffffffffffffffffL, 0x3cdfffffffffffffL, 0xfffffffbffffd740L, 0xffbfffffffffffffL +}; +static final long[] jjbitVec61 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffffcfbL, 0xffffffffffffffffL +}; +static final long[] jjbitVec62 = { + 0xfffe00ffffffffffL, 0xfffffffe027fffffL, 0xbffffffffffe80ffL, 0x707ffffff00b6L +}; +static final long[] jjbitVec63 = { + 0xffffffff07ff081fL, 0xffffc3ffffffffffL, 0xffffffffffffffffL, 0x9ffffdffbfefffffL +}; +static final long[] jjbitVec64 = { + 0xffffffffffff8000L, 0xffffffffffffe7ffL, 0x3ffffffffffffL, 0x43fffffffffffffL +}; +static final long[] jjbitVec65 = { + 0x3fffffffffffL, 0xfffffffL, 0x1ffd00000000L, 0x7ffffff000000000L +}; +static final long[] jjbitVec66 = { + 0xffffffffffffffffL, 0xfefeffcfffffffffL, 0xf3c5fdfffff99feeL, 0x80fffcfb080799fL +}; +static final long[] jjbitVec67 = { + 0xd36dfdfffff987eeL, 0x3fffc05e023987L, 0xf3edfdfffffbbfeeL, 0x2ffcf00013bbfL +}; +static final long[] jjbitVec68 = { + 0xf3edfdfffff99feeL, 0x2ffcfb0c0399fL, 0xc3ffc718d63dc7ecL, 0x200ffc000813dc7L +}; +static final long[] jjbitVec69 = { + 0xe3effdfffffddfeeL, 0xffcf03603ddfL, 0xf3effdfffffddfecL, 0x6ffcf40603ddfL +}; +static final long[] jjbitVec70 = { + 0xe7fffffffffddfecL, 0xfc00ffcf00807ddfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL +}; +static final long[] jjbitVec71 = { + 0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0xf3ff3f5fL +}; +static final long[] jjbitVec72 = { + 0xc2a003ff03000001L, 0xfffe1ffffffffeffL, 0x1ffffffffeffffdfL, 0x40L +}; +static final long[] jjbitVec73 = { + 0xffffffffffffffffL, 0xffffffffffff03ffL, 0xffffffff3fffffffL, 0xf7ffffffffff20bfL +}; +static final long[] jjbitVec74 = { + 0xffffffffff3dffffL, 0xe7ffffffL, 0xffffffff0000ffffL, 0x1fffffffffffffL +}; +static final long[] jjbitVec75 = { + 0x1fffff001fdfffL, 0xddfff000fffffL, 0xffffffffffffffffL, 0x3ff388fffffL +}; +static final long[] jjbitVec76 = { + 0xffffffff03ff3800L, 0xffffffffffffffL, 0xffff07ffffffffffL, 0x3fffffffffffffL +}; +static final long[] jjbitVec77 = { + 0xfff0fff1fffffffL, 0x1f3fffffffffc0L, 0xffff0fffffffffffL, 0x3ff03ffL +}; +static final long[] jjbitVec78 = { + 0xffffffff0fffffffL, 0x9fffffff7fffffffL, 0x8003ff03ffL, 0x0L +}; +static final long[] jjbitVec79 = { + 0xffffffffffffffffL, 0xff80003ff0fffL, 0xffffffffffffffffL, 0xfffffffffffffL +}; +static final long[] jjbitVec80 = { + 0xffffffffffffffL, 0x3fffffffffffe3ffL, 0x0L, 0x7ffffffff70000L +}; +static final long[] jjbitVec81 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xf000007fffffffffL +}; +static final long[] jjbitVec82 = { + 0x80007c000000f800L, 0x8002fc1f00100001L, 0x7ffffff1fff0000L, 0x1ffe21fff0000L +}; +static final long[] jjbitVec83 = { + 0xffff7fffffffffffL, 0xffffffff7fffffffL, 0xffffffffffffffffL, 0xff81fffffffffL +}; +static final long[] jjbitVec84 = { + 0xffff20bfffffffffL, 0x800080ffffffffffL, 0x7f7f7f7f007fffffL, 0xffffffff7f7f7f7fL +}; +static final long[] jjbitVec85 = { + 0x1f3efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffee67fffffL, 0xf7ffffffffffffffL +}; +static final long[] jjbitVec86 = { + 0xfffffff1fffL, 0xbff0ffffffffffffL, 0xffffffff80ffffffL, 0x3ffffffffffffL +}; +static final long[] jjbitVec87 = { + 0x10000ffffffffffL, 0xfffffffffffffL, 0xffffffffffffffffL, 0x8ffffff03ff001fL +}; +static final long[] jjbitVec88 = { + 0xffff3fffffffffffL, 0x1fffffff000fffffL, 0xffffffffffffffffL, 0x3ff8001L +}; +static final long[] jjbitVec89 = { + 0x7fffffffffffffL, 0xc7fffff03ff3fffL, 0xffffffffffffffffL, 0x7cffff38000007L +}; +static final long[] jjbitVec90 = { + 0x7f7f007e7e7eL, 0x0L, 0x0L, 0x3ff37ffffffffffL +}; +static final long[] jjbitVec91 = { + 0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L +}; +static final long[] jjbitVec92 = { + 0x18007f0000ffffL, 0xffdf02000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL +}; +static final long[] jjbitVec93 = { + 0x87fffffe03ff0010L, 0xffffffc007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL +}; +private int jjMoveNfa_0(int startState, int curPos) +{ + int startsAt = 0; + jjnewStateCnt = 144; + int i = 1; + jjstateSet[0] = startState; + int kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + do + { + switch(jjstateSet[--i]) + { + case 144: + case 43: + if ((0x3ff00100fffc1ffL & l) == 0L) + break; + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + break; + case 56: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 61; + else if (curChar == 47) + { + if (kind > 5) + kind = 5; + { jjCheckNAddStates(0, 2); } + } + break; + case 0: + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 75) + kind = 75; + { jjCheckNAddStates(3, 17); } + } + else if ((0x100001200L & l) != 0L) + { + if (kind > 1) + kind = 1; + } + else if (curChar == 47) + { jjAddStates(18, 19); } + else if (curChar == 36) + { + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + } + else if (curChar == 34) + { jjCheckNAddStates(20, 23); } + else if (curChar == 39) + { jjAddStates(24, 26); } + else if (curChar == 46) + jjstateSet[jjnewStateCnt++] = 2; + if (curChar == 48) + { jjAddStates(27, 34); } + break; + case 1: + if (curChar == 46) + jjstateSet[jjnewStateCnt++] = 2; + break; + case 2: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(35, 38); } + break; + case 3: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(3, 4); } + break; + case 4: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddTwoStates(5, 10); } + break; + case 6: + if ((0x280000000000L & l) != 0L) + { jjCheckNAdd(7); } + break; + case 7: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(39, 41); } + break; + case 8: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(8, 9); } + break; + case 9: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddTwoStates(7, 10); } + break; + case 11: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(42, 45); } + break; + case 12: + if (curChar == 39) + { jjAddStates(24, 26); } + break; + case 13: + if ((0xffffff7fffffdbffL & l) != 0L) + { jjCheckNAdd(14); } + break; + case 14: + if (curChar == 39 && kind > 87) + kind = 87; + break; + case 16: + if ((0x8400000000L & l) != 0L) + { jjCheckNAdd(14); } + break; + case 17: + if ((0xff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(18, 14); } + break; + case 18: + if ((0xff000000000000L & l) != 0L) + { jjCheckNAdd(14); } + break; + case 19: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 20; + break; + case 20: + if ((0xff000000000000L & l) != 0L) + { jjCheckNAdd(18); } + break; + case 22: + if ((0x3ff000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 23; + break; + case 23: + if ((0x3ff000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 24; + break; + case 24: + if ((0x3ff000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 25; + break; + case 25: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAdd(14); } + break; + case 27: + if (curChar == 34) + { jjCheckNAddStates(20, 23); } + break; + case 28: + if ((0xfffffffbffffdbffL & l) != 0L) + { jjCheckNAddStates(20, 23); } + break; + case 30: + if ((0x8400000000L & l) != 0L) + { jjCheckNAddStates(20, 23); } + break; + case 32: + if ((0x3ff000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 33; + break; + case 33: + if ((0x3ff000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 34; + break; + case 34: + if ((0x3ff000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 35; + break; + case 35: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddStates(20, 23); } + break; + case 37: + if (curChar == 34 && kind > 88) + kind = 88; + break; + case 38: + if ((0xff000000000000L & l) != 0L) + { jjCheckNAddStates(46, 50); } + break; + case 39: + if ((0xff000000000000L & l) != 0L) + { jjCheckNAddStates(20, 23); } + break; + case 40: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 41; + break; + case 41: + if ((0xff000000000000L & l) != 0L) + { jjCheckNAdd(39); } + break; + case 42: + if (curChar != 36) + break; + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + break; + case 45: + if ((0x3ff000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 46; + break; + case 46: + if ((0x3ff000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 47; + break; + case 47: + case 53: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAdd(48); } + break; + case 48: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + break; + case 51: + if ((0x3ff000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 52; + break; + case 52: + if ((0x3ff000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 53; + break; + case 55: + if (curChar == 47) + { jjAddStates(18, 19); } + break; + case 57: + if ((0xffffffffffffdbffL & l) == 0L) + break; + if (kind > 5) + kind = 5; + { jjCheckNAddStates(0, 2); } + break; + case 58: + if ((0x2400L & l) != 0L && kind > 5) + kind = 5; + break; + case 59: + if (curChar == 10 && kind > 5) + kind = 5; + break; + case 60: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 59; + break; + case 61: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 62; + break; + case 62: + if ((0xffff7fffffffffffL & l) != 0L && kind > 6) + kind = 6; + break; + case 63: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 61; + break; + case 64: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 75) + kind = 75; + { jjCheckNAddStates(3, 17); } + break; + case 65: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(65, 66); } + break; + case 66: + case 102: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAdd(67); } + break; + case 68: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(68, 69); } + break; + case 69: + case 113: + if ((0x3ff000000000000L & l) != 0L && kind > 75) + kind = 75; + break; + case 70: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(70, 71); } + break; + case 71: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(72, 10); } + break; + case 73: + if ((0x280000000000L & l) != 0L) + { jjCheckNAdd(74); } + break; + case 74: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddStates(51, 53); } + break; + case 75: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(75, 76); } + break; + case 76: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(74, 10); } + break; + case 77: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddStates(54, 57); } + break; + case 78: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(78, 79); } + break; + case 79: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAdd(80); } + break; + case 81: + if ((0x280000000000L & l) != 0L) + { jjCheckNAdd(82); } + break; + case 82: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(58, 60); } + break; + case 83: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(83, 84); } + break; + case 84: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddTwoStates(82, 10); } + break; + case 85: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(61, 64); } + break; + case 86: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(86, 87); } + break; + case 87: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAdd(88); } + break; + case 88: + if (curChar != 46) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(65, 67); } + break; + case 89: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(68, 71); } + break; + case 90: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(90, 91); } + break; + case 91: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddTwoStates(92, 10); } + break; + case 93: + if ((0x280000000000L & l) != 0L) + { jjCheckNAdd(94); } + break; + case 94: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(72, 74); } + break; + case 95: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(95, 96); } + break; + case 96: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddTwoStates(94, 10); } + break; + case 97: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(75, 78); } + break; + case 98: + if (curChar == 48) + { jjAddStates(27, 34); } + break; + case 100: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddStates(79, 81); } + break; + case 101: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(101, 102); } + break; + case 103: + if ((0xff000000000000L & l) != 0L) + { jjCheckNAddStates(82, 84); } + break; + case 104: + if ((0xff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(104, 105); } + break; + case 105: + if ((0xff000000000000L & l) != 0L) + { jjCheckNAdd(67); } + break; + case 107: + if ((0x3000000000000L & l) != 0L) + { jjCheckNAddStates(85, 87); } + break; + case 108: + if ((0x3000000000000L & l) != 0L) + { jjCheckNAddTwoStates(108, 109); } + break; + case 109: + if ((0x3000000000000L & l) != 0L) + { jjCheckNAdd(67); } + break; + case 111: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 75) + kind = 75; + { jjCheckNAddTwoStates(112, 113); } + break; + case 112: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(112, 113); } + break; + case 114: + if ((0xff000000000000L & l) == 0L) + break; + if (kind > 75) + kind = 75; + { jjCheckNAddTwoStates(115, 116); } + break; + case 115: + if ((0xff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(115, 116); } + break; + case 116: + if ((0xff000000000000L & l) != 0L && kind > 75) + kind = 75; + break; + case 118: + if ((0x3000000000000L & l) == 0L) + break; + if (kind > 75) + kind = 75; + { jjCheckNAddTwoStates(119, 120); } + break; + case 119: + if ((0x3000000000000L & l) != 0L) + { jjCheckNAddTwoStates(119, 120); } + break; + case 120: + if ((0x3000000000000L & l) != 0L && kind > 75) + kind = 75; + break; + case 122: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddStates(88, 90); } + break; + case 123: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(123, 124); } + break; + case 124: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAdd(125); } + break; + case 125: + if (curChar == 46) + jjstateSet[jjnewStateCnt++] = 126; + break; + case 126: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddStates(91, 93); } + break; + case 127: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(127, 128); } + break; + case 128: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAdd(129); } + break; + case 130: + if ((0x280000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 131; + break; + case 131: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(94, 96); } + break; + case 132: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(132, 133); } + break; + case 133: + case 143: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAdd(10); } + break; + case 135: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddStates(97, 100); } + break; + case 136: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(136, 137); } + break; + case 137: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(138, 139); } + break; + case 138: + if (curChar == 46) + { jjCheckNAdd(139); } + break; + case 140: + if ((0x280000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 141; + break; + case 141: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 80) + kind = 80; + { jjCheckNAddStates(101, 103); } + break; + case 142: + if ((0x3ff000000000000L & l) != 0L) + { jjCheckNAddTwoStates(142, 143); } + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + do + { + switch(jjstateSet[--i]) + { + case 144: + if ((0x87fffffe87fffffeL & l) != 0L) + { + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + } + else if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 44; + break; + case 0: + if ((0x7fffffe87fffffeL & l) != 0L) + { + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + } + else if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 50; + break; + case 3: + if (curChar == 95) + { jjAddStates(104, 105); } + break; + case 5: + if ((0x2000000020L & l) != 0L) + { jjAddStates(106, 107); } + break; + case 8: + if (curChar == 95) + { jjAddStates(108, 109); } + break; + case 10: + if ((0x5000000050L & l) != 0L && kind > 80) + kind = 80; + break; + case 13: + if ((0xffffffffefffffffL & l) != 0L) + { jjCheckNAdd(14); } + break; + case 15: + if (curChar == 92) + { jjAddStates(110, 112); } + break; + case 16: + if ((0x14404410000000L & l) != 0L) + { jjCheckNAdd(14); } + break; + case 21: + if (curChar == 117) + jjstateSet[jjnewStateCnt++] = 22; + break; + case 22: + if ((0x7e0000007eL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 23; + break; + case 23: + if ((0x7e0000007eL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 24; + break; + case 24: + if ((0x7e0000007eL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 25; + break; + case 25: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAdd(14); } + break; + case 26: + if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 21; + break; + case 28: + if ((0xffffffffefffffffL & l) != 0L) + { jjCheckNAddStates(20, 23); } + break; + case 29: + if (curChar == 92) + { jjAddStates(113, 115); } + break; + case 30: + if ((0x14404410000000L & l) != 0L) + { jjCheckNAddStates(20, 23); } + break; + case 31: + if (curChar == 117) + jjstateSet[jjnewStateCnt++] = 32; + break; + case 32: + if ((0x7e0000007eL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 33; + break; + case 33: + if ((0x7e0000007eL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 34; + break; + case 34: + if ((0x7e0000007eL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 35; + break; + case 35: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAddStates(20, 23); } + break; + case 36: + if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 31; + break; + case 42: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + break; + case 43: + if ((0x87fffffe87fffffeL & l) == 0L) + break; + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + break; + case 44: + if (curChar == 117) + jjstateSet[jjnewStateCnt++] = 45; + break; + case 45: + if ((0x7e0000007eL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 46; + break; + case 46: + if ((0x7e0000007eL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 47; + break; + case 47: + case 53: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAdd(48); } + break; + case 48: + if ((0x7e0000007eL & l) == 0L) + break; + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + break; + case 49: + if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 44; + break; + case 50: + if (curChar == 117) + jjstateSet[jjnewStateCnt++] = 51; + break; + case 51: + if ((0x7e0000007eL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 52; + break; + case 52: + if ((0x7e0000007eL & l) != 0L) + jjstateSet[jjnewStateCnt++] = 53; + break; + case 54: + if (curChar == 92) + jjstateSet[jjnewStateCnt++] = 50; + break; + case 57: + if (kind > 5) + kind = 5; + { jjAddStates(0, 2); } + break; + case 62: + if (kind > 6) + kind = 6; + break; + case 65: + if (curChar == 95) + { jjAddStates(116, 117); } + break; + case 67: + if ((0x100000001000L & l) != 0L && kind > 74) + kind = 74; + break; + case 68: + if (curChar == 95) + { jjAddStates(118, 119); } + break; + case 70: + if (curChar == 95) + { jjAddStates(120, 121); } + break; + case 72: + if ((0x2000000020L & l) != 0L) + { jjAddStates(122, 123); } + break; + case 75: + if (curChar == 95) + { jjAddStates(124, 125); } + break; + case 78: + if (curChar == 95) + { jjAddStates(126, 127); } + break; + case 80: + if ((0x2000000020L & l) != 0L) + { jjAddStates(128, 129); } + break; + case 83: + if (curChar == 95) + { jjAddStates(130, 131); } + break; + case 86: + if (curChar == 95) + { jjAddStates(132, 133); } + break; + case 90: + if (curChar == 95) + { jjAddStates(134, 135); } + break; + case 92: + if ((0x2000000020L & l) != 0L) + { jjAddStates(136, 137); } + break; + case 95: + if (curChar == 95) + { jjAddStates(138, 139); } + break; + case 99: + if ((0x100000001000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 100; + break; + case 100: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAddStates(79, 81); } + break; + case 101: + if ((0x7e8000007eL & l) != 0L) + { jjCheckNAddTwoStates(101, 102); } + break; + case 102: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAdd(67); } + break; + case 104: + if (curChar == 95) + { jjAddStates(140, 141); } + break; + case 106: + if ((0x400000004L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 107; + break; + case 108: + if (curChar == 95) + { jjAddStates(142, 143); } + break; + case 110: + if ((0x100000001000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 111; + break; + case 111: + if ((0x7e0000007eL & l) == 0L) + break; + if (kind > 75) + kind = 75; + { jjCheckNAddTwoStates(112, 113); } + break; + case 112: + if ((0x7e8000007eL & l) != 0L) + { jjCheckNAddTwoStates(112, 113); } + break; + case 113: + if ((0x7e0000007eL & l) != 0L && kind > 75) + kind = 75; + break; + case 115: + if (curChar == 95) + { jjAddStates(144, 145); } + break; + case 117: + if ((0x400000004L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 118; + break; + case 119: + if (curChar == 95) + { jjAddStates(146, 147); } + break; + case 121: + if ((0x100000001000000L & l) != 0L) + { jjCheckNAddTwoStates(122, 125); } + break; + case 122: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAddStates(88, 90); } + break; + case 123: + if ((0x7e8000007eL & l) != 0L) + { jjCheckNAddTwoStates(123, 124); } + break; + case 124: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAdd(125); } + break; + case 126: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAddStates(91, 93); } + break; + case 127: + if ((0x7e8000007eL & l) != 0L) + { jjCheckNAddTwoStates(127, 128); } + break; + case 128: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAdd(129); } + break; + case 129: + if ((0x1000000010000L & l) != 0L) + { jjAddStates(148, 149); } + break; + case 132: + if (curChar == 95) + { jjAddStates(150, 151); } + break; + case 134: + if ((0x100000001000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 135; + break; + case 135: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAddStates(97, 100); } + break; + case 136: + if ((0x7e8000007eL & l) != 0L) + { jjCheckNAddTwoStates(136, 137); } + break; + case 137: + if ((0x7e0000007eL & l) != 0L) + { jjCheckNAddTwoStates(138, 139); } + break; + case 139: + if ((0x1000000010000L & l) != 0L) + { jjAddStates(152, 153); } + break; + case 142: + if (curChar == 95) + { jjAddStates(154, 155); } + break; + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + do + { + switch(jjstateSet[--i]) + { + case 144: + case 43: + if (!jjCanMove_3(hiByte, i1, i2, l1, l2)) + break; + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + break; + case 0: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + { + if (kind > 1) + kind = 1; + } + if (jjCanMove_2(hiByte, i1, i2, l1, l2)) + { + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + } + break; + case 13: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + jjstateSet[jjnewStateCnt++] = 14; + break; + case 28: + if (jjCanMove_1(hiByte, i1, i2, l1, l2)) + { jjAddStates(20, 23); } + break; + case 42: + if (!jjCanMove_2(hiByte, i1, i2, l1, l2)) + break; + if (kind > 89) + kind = 89; + { jjCheckNAddTwoStates(43, 49); } + break; + case 57: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 5) + kind = 5; + { jjAddStates(0, 2); } + break; + case 62: + if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 6) + kind = 6; + break; + default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 144 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private int jjMoveStringLiteralDfa0_2(){ + switch(curChar) + { + case 42: + return jjMoveStringLiteralDfa1_2(0x200L); + default : + return 1; + } +} +private int jjMoveStringLiteralDfa1_2(long active0){ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + return 1; + } + switch(curChar) + { + case 47: + if ((active0 & 0x200L) != 0L) + return jjStopAtPos(1, 9); + break; + default : + return 2; + } + return 2; +} +private int jjMoveStringLiteralDfa0_1(){ + switch(curChar) + { + case 42: + return jjMoveStringLiteralDfa1_1(0x100L); + default : + return 1; + } +} +private int jjMoveStringLiteralDfa1_1(long active0){ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + return 1; + } + switch(curChar) + { + case 47: + if ((active0 & 0x100L) != 0L) + return jjStopAtPos(1, 8); + break; + default : + return 2; + } + return 2; +} + +/** Token literal values. */ +public static final String[] jjstrLiteralImages = { +"", null, null, null, null, null, null, null, null, null, null, +"\141\142\163\164\162\141\143\164", "\141\163\163\145\162\164", "\142\157\157\154\145\141\156", +"\142\162\145\141\153", "\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150", +"\143\150\141\162", "\143\154\141\163\163", "\143\157\156\163\164", +"\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145", +"\145\154\163\145", "\145\156\165\155", "\145\170\164\145\156\144\163", "\146\141\154\163\145", +"\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", +"\147\157\164\157", "\151\146", "\151\155\160\154\145\155\145\156\164\163", +"\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164", +"\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145", "\156\145\167", +"\156\165\154\154", "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145", +"\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\164\165\162\156", +"\163\150\157\162\164", "\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160", +"\163\165\160\145\162", "\163\167\151\164\143\150", +"\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", "\164\150\162\157\167", "\164\150\162\157\167\163", +"\164\162\141\156\163\151\145\156\164", "\164\162\165\145", "\164\162\171", "\166\157\151\144", +"\166\157\154\141\164\151\154\145", "\167\150\151\154\145", "\162\145\161\165\151\162\145\163", "\164\157", +"\167\151\164\150", "\157\160\145\156", "\157\160\145\156\163", "\165\163\145\163", +"\155\157\144\165\154\145", "\145\170\160\157\162\164\163", "\160\162\157\166\151\144\145\163", +"\164\162\141\156\163\151\164\151\166\145", null, null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", +"\54", "\56", "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", +"\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", +"\57", "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75", +"\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", +"\76\76\76\75", "\56\56\56", "\55\76", "\72\72", "\76\76\76", "\76\76", "\76", "\32", }; +protected Token jjFillToken() +{ + final Token t; + final String curTokenImage; + final int beginLine; + final int endLine; + final int beginColumn; + final int endColumn; + String im = jjstrLiteralImages[jjmatchedKind]; + curTokenImage = (im == null) ? input_stream.GetImage() : im; + beginLine = input_stream.getBeginLine(); + beginColumn = input_stream.getBeginColumn(); + endLine = input_stream.getEndLine(); + endColumn = input_stream.getEndColumn(); + t = Token.newToken(jjmatchedKind); + t.kind = jjmatchedKind; + t.image = curTokenImage; + + t.beginLine = beginLine; + t.endLine = endLine; + t.beginColumn = beginColumn; + t.endColumn = endColumn; + + return t; +} +static final int[] jjnextStates = { + 57, 58, 60, 65, 66, 67, 68, 69, 70, 71, 72, 10, 78, 79, 80, 86, + 87, 88, 56, 63, 28, 29, 36, 37, 13, 15, 26, 99, 103, 106, 110, 114, + 117, 121, 134, 3, 4, 5, 10, 8, 10, 11, 7, 8, 10, 11, 28, 29, + 39, 36, 37, 75, 10, 77, 74, 75, 10, 77, 83, 10, 85, 82, 83, 10, + 85, 89, 92, 10, 90, 91, 92, 10, 95, 10, 97, 94, 95, 10, 97, 101, + 102, 67, 104, 105, 67, 108, 109, 67, 123, 124, 125, 127, 128, 129, 132, 133, + 10, 136, 137, 138, 139, 142, 143, 10, 3, 4, 6, 7, 8, 9, 16, 17, + 19, 30, 38, 40, 65, 66, 68, 69, 70, 71, 73, 74, 75, 76, 78, 79, + 81, 82, 83, 84, 86, 87, 90, 91, 93, 94, 95, 96, 104, 105, 108, 109, + 115, 116, 119, 120, 130, 131, 132, 133, 140, 141, 142, 143, +}; +private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec0[i2] & l2) != 0L); + case 22: + return ((jjbitVec1[i2] & l2) != 0L); + case 24: + return ((jjbitVec2[i2] & l2) != 0L); + case 32: + return ((jjbitVec3[i2] & l2) != 0L); + case 48: + return ((jjbitVec4[i2] & l2) != 0L); + case 254: + return ((jjbitVec5[i2] & l2) != 0L); + default : + return false; + } +} +private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec8[i2] & l2) != 0L); + default : + if ((jjbitVec6[i1] & l1) != 0L) + return true; + return false; + } +} +private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec10[i2] & l2) != 0L); + case 2: + return ((jjbitVec11[i2] & l2) != 0L); + case 3: + return ((jjbitVec12[i2] & l2) != 0L); + case 4: + return ((jjbitVec13[i2] & l2) != 0L); + case 5: + return ((jjbitVec14[i2] & l2) != 0L); + case 6: + return ((jjbitVec15[i2] & l2) != 0L); + case 7: + return ((jjbitVec16[i2] & l2) != 0L); + case 8: + return ((jjbitVec17[i2] & l2) != 0L); + case 9: + return ((jjbitVec18[i2] & l2) != 0L); + case 10: + return ((jjbitVec19[i2] & l2) != 0L); + case 11: + return ((jjbitVec20[i2] & l2) != 0L); + case 12: + return ((jjbitVec21[i2] & l2) != 0L); + case 13: + return ((jjbitVec22[i2] & l2) != 0L); + case 14: + return ((jjbitVec23[i2] & l2) != 0L); + case 15: + return ((jjbitVec24[i2] & l2) != 0L); + case 16: + return ((jjbitVec25[i2] & l2) != 0L); + case 18: + return ((jjbitVec26[i2] & l2) != 0L); + case 19: + return ((jjbitVec27[i2] & l2) != 0L); + case 20: + return ((jjbitVec6[i2] & l2) != 0L); + case 22: + return ((jjbitVec28[i2] & l2) != 0L); + case 23: + return ((jjbitVec29[i2] & l2) != 0L); + case 24: + return ((jjbitVec30[i2] & l2) != 0L); + case 25: + return ((jjbitVec31[i2] & l2) != 0L); + case 26: + return ((jjbitVec32[i2] & l2) != 0L); + case 27: + return ((jjbitVec33[i2] & l2) != 0L); + case 28: + return ((jjbitVec34[i2] & l2) != 0L); + case 29: + return ((jjbitVec35[i2] & l2) != 0L); + case 31: + return ((jjbitVec36[i2] & l2) != 0L); + case 32: + return ((jjbitVec37[i2] & l2) != 0L); + case 33: + return ((jjbitVec38[i2] & l2) != 0L); + case 44: + return ((jjbitVec39[i2] & l2) != 0L); + case 45: + return ((jjbitVec40[i2] & l2) != 0L); + case 46: + return ((jjbitVec41[i2] & l2) != 0L); + case 48: + return ((jjbitVec42[i2] & l2) != 0L); + case 49: + return ((jjbitVec43[i2] & l2) != 0L); + case 77: + return ((jjbitVec44[i2] & l2) != 0L); + case 159: + return ((jjbitVec45[i2] & l2) != 0L); + case 164: + return ((jjbitVec46[i2] & l2) != 0L); + case 166: + return ((jjbitVec47[i2] & l2) != 0L); + case 167: + return ((jjbitVec48[i2] & l2) != 0L); + case 168: + return ((jjbitVec49[i2] & l2) != 0L); + case 169: + return ((jjbitVec50[i2] & l2) != 0L); + case 170: + return ((jjbitVec51[i2] & l2) != 0L); + case 171: + return ((jjbitVec52[i2] & l2) != 0L); + case 215: + return ((jjbitVec53[i2] & l2) != 0L); + case 250: + return ((jjbitVec54[i2] & l2) != 0L); + case 251: + return ((jjbitVec55[i2] & l2) != 0L); + case 253: + return ((jjbitVec56[i2] & l2) != 0L); + case 254: + return ((jjbitVec57[i2] & l2) != 0L); + case 255: + return ((jjbitVec58[i2] & l2) != 0L); + default : + if ((jjbitVec9[i1] & l1) != 0L) + return true; + return false; + } +} +private static final boolean jjCanMove_3(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec59[i2] & l2) != 0L); + case 2: + return ((jjbitVec11[i2] & l2) != 0L); + case 3: + return ((jjbitVec60[i2] & l2) != 0L); + case 4: + return ((jjbitVec61[i2] & l2) != 0L); + case 5: + return ((jjbitVec62[i2] & l2) != 0L); + case 6: + return ((jjbitVec63[i2] & l2) != 0L); + case 7: + return ((jjbitVec64[i2] & l2) != 0L); + case 8: + return ((jjbitVec65[i2] & l2) != 0L); + case 9: + return ((jjbitVec66[i2] & l2) != 0L); + case 10: + return ((jjbitVec67[i2] & l2) != 0L); + case 11: + return ((jjbitVec68[i2] & l2) != 0L); + case 12: + return ((jjbitVec69[i2] & l2) != 0L); + case 13: + return ((jjbitVec70[i2] & l2) != 0L); + case 14: + return ((jjbitVec71[i2] & l2) != 0L); + case 15: + return ((jjbitVec72[i2] & l2) != 0L); + case 16: + return ((jjbitVec73[i2] & l2) != 0L); + case 18: + return ((jjbitVec26[i2] & l2) != 0L); + case 19: + return ((jjbitVec74[i2] & l2) != 0L); + case 20: + return ((jjbitVec6[i2] & l2) != 0L); + case 22: + return ((jjbitVec28[i2] & l2) != 0L); + case 23: + return ((jjbitVec75[i2] & l2) != 0L); + case 24: + return ((jjbitVec76[i2] & l2) != 0L); + case 25: + return ((jjbitVec77[i2] & l2) != 0L); + case 26: + return ((jjbitVec78[i2] & l2) != 0L); + case 27: + return ((jjbitVec79[i2] & l2) != 0L); + case 28: + return ((jjbitVec80[i2] & l2) != 0L); + case 29: + return ((jjbitVec81[i2] & l2) != 0L); + case 31: + return ((jjbitVec36[i2] & l2) != 0L); + case 32: + return ((jjbitVec82[i2] & l2) != 0L); + case 33: + return ((jjbitVec38[i2] & l2) != 0L); + case 44: + return ((jjbitVec83[i2] & l2) != 0L); + case 45: + return ((jjbitVec84[i2] & l2) != 0L); + case 46: + return ((jjbitVec41[i2] & l2) != 0L); + case 48: + return ((jjbitVec85[i2] & l2) != 0L); + case 49: + return ((jjbitVec43[i2] & l2) != 0L); + case 77: + return ((jjbitVec44[i2] & l2) != 0L); + case 159: + return ((jjbitVec45[i2] & l2) != 0L); + case 164: + return ((jjbitVec46[i2] & l2) != 0L); + case 166: + return ((jjbitVec86[i2] & l2) != 0L); + case 167: + return ((jjbitVec48[i2] & l2) != 0L); + case 168: + return ((jjbitVec87[i2] & l2) != 0L); + case 169: + return ((jjbitVec88[i2] & l2) != 0L); + case 170: + return ((jjbitVec89[i2] & l2) != 0L); + case 171: + return ((jjbitVec90[i2] & l2) != 0L); + case 215: + return ((jjbitVec53[i2] & l2) != 0L); + case 250: + return ((jjbitVec54[i2] & l2) != 0L); + case 251: + return ((jjbitVec91[i2] & l2) != 0L); + case 253: + return ((jjbitVec56[i2] & l2) != 0L); + case 254: + return ((jjbitVec92[i2] & l2) != 0L); + case 255: + return ((jjbitVec93[i2] & l2) != 0L); + default : + if ((jjbitVec9[i1] & l1) != 0L) + return true; + return false; + } +} + +int curLexState = 0; +int defaultLexState = 0; +int jjnewStateCnt; +int jjround; +int jjmatchedPos; +int jjmatchedKind; + +/** Get the next Token. */ +public Token getNextToken() +{ + Token specialToken = null; + Token matchedToken; + int curPos = 0; + + EOFLoop : + for (;;) + { + try + { + curChar = input_stream.BeginToken(); + } + catch(Exception e) + { + jjmatchedKind = 0; + jjmatchedPos = -1; + matchedToken = jjFillToken(); + matchedToken.specialToken = specialToken; + CommonTokenAction(matchedToken); + return matchedToken; + } + image = jjimage; + image.setLength(0); + jjimageLen = 0; + + for (;;) + { + switch(curLexState) + { + case 0: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_0(); + break; + case 1: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_1(); + if (jjmatchedPos == 0 && jjmatchedKind > 10) + { + jjmatchedKind = 10; + } + break; + case 2: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_2(); + if (jjmatchedPos == 0 && jjmatchedKind > 10) + { + jjmatchedKind = 10; + } + break; + } + if (jjmatchedKind != 0x7fffffff) + { + if (jjmatchedPos + 1 < curPos) + input_stream.backup(curPos - jjmatchedPos - 1); + if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + matchedToken.specialToken = specialToken; + TokenLexicalActions(matchedToken); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + CommonTokenAction(matchedToken); + return matchedToken; + } + else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + if (specialToken == null) + specialToken = matchedToken; + else + { + matchedToken.specialToken = specialToken; + specialToken = (specialToken.next = matchedToken); + } + SkipLexicalActions(matchedToken); + } + else + SkipLexicalActions(null); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + continue EOFLoop; + } + MoreLexicalActions(); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + curPos = 0; + jjmatchedKind = 0x7fffffff; + try { + curChar = input_stream.readChar(); + continue; + } + catch (java.io.IOException e1) { } + } + int error_line = input_stream.getEndLine(); + int error_column = input_stream.getEndColumn(); + String error_after = null; + boolean EOFSeen = false; + try { input_stream.readChar(); input_stream.backup(1); } + catch (java.io.IOException e1) { + EOFSeen = true; + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + if (curChar == '\n' || curChar == '\r') { + error_line++; + error_column = 0; + } + else + error_column++; + } + if (!EOFSeen) { + input_stream.backup(1); + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + } + throw new TokenMgrException(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrException.LEXICAL_ERROR); + } + } +} + +void SkipLexicalActions(Token matchedToken) +{ + switch(jjmatchedKind) + { + default : + break; + } +} +void MoreLexicalActions() +{ + jjimageLen += (lengthOfMatch = jjmatchedPos + 1); + switch(jjmatchedKind) + { + case 6 : + image.append(input_stream.GetSuffix(jjimageLen)); + jjimageLen = 0; + input_stream.backup(1); + break; + default : + break; + } +} +void TokenLexicalActions(Token matchedToken) +{ + switch(jjmatchedKind) + { + case 139 : + image.append(jjstrLiteralImages[139]); + lengthOfMatch = jjstrLiteralImages[139].length(); + matchedToken.kind = GT; + matchedToken.realKind = RUNSIGNEDSHIFT; + input_stream.backup(2); + break; + case 140 : + image.append(jjstrLiteralImages[140]); + lengthOfMatch = jjstrLiteralImages[140].length(); + matchedToken.kind = GT; + matchedToken.realKind = RSIGNEDSHIFT; + input_stream.backup(1); + break; + default : + break; + } +} +private void jjCheckNAdd(int state) +{ + if (jjrounds[state] != jjround) + { + jjstateSet[jjnewStateCnt++] = state; + jjrounds[state] = jjround; + } +} +private void jjAddStates(int start, int end) +{ + do { + jjstateSet[jjnewStateCnt++] = jjnextStates[start]; + } while (start++ != end); +} +private void jjCheckNAddTwoStates(int state1, int state2) +{ + jjCheckNAdd(state1); + jjCheckNAdd(state2); +} + +private void jjCheckNAddStates(int start, int end) +{ + do { + jjCheckNAdd(jjnextStates[start]); + } while (start++ != end); +} + + /** Constructor. */ + public GeneratedJavaParserTokenManager(SimpleCharStream stream){ + + if (SimpleCharStream.staticFlag) + throw new RuntimeException("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); + + input_stream = stream; + } + + /** Constructor. */ + public GeneratedJavaParserTokenManager (SimpleCharStream stream, int lexState){ + ReInit(stream); + SwitchTo(lexState); + } + + /** Reinitialise parser. */ + + public void ReInit(SimpleCharStream stream) + { + + + jjmatchedPos = + jjnewStateCnt = + 0; + curLexState = defaultLexState; + input_stream = stream; + ReInitRounds(); + } + + private void ReInitRounds() + { + int i; + jjround = 0x80000001; + for (i = 144; i-- > 0;) + jjrounds[i] = 0x80000000; + } + + /** Reinitialise parser. */ + public void ReInit(SimpleCharStream stream, int lexState) + + { + ReInit(stream); + SwitchTo(lexState); + } + + /** Switch to specified lex state. */ + public void SwitchTo(int lexState) + { + if (lexState >= 3 || lexState < 0) + throw new TokenMgrException("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrException.INVALID_LEXICAL_STATE); + else + curLexState = lexState; + } + + +/** Lexer state names. */ +public static final String[] lexStateNames = { + "DEFAULT", + "IN_JAVADOC_COMMENT", + "IN_MULTI_LINE_COMMENT", +}; + +/** Lex State array. */ +public static final int[] jjnewLexState = { + -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +}; +static final long[] jjtoToken = { + 0xfffffffffffff801L, 0xfffffffff3810fffL, 0x7fffL, +}; +static final long[] jjtoSkip = { + 0x33eL, 0x0L, 0x0L, +}; +static final long[] jjtoSpecial = { + 0x33eL, 0x0L, 0x0L, +}; +static final long[] jjtoMore = { + 0x4c0L, 0x0L, 0x0L, +}; + protected SimpleCharStream input_stream; + + private final int[] jjrounds = new int[144]; + private final int[] jjstateSet = new int[2 * 144]; + private final StringBuilder jjimage = new StringBuilder(); + private StringBuilder image = jjimage; + private int jjimageLen; + private int lengthOfMatch; + protected int curChar; +} diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/ParseException.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/ParseException.java new file mode 100644 index 000000000..5d25eae39 --- /dev/null +++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/ParseException.java @@ -0,0 +1,235 @@ +/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 7.0 */ +/* JavaCCOptions:KEEP_LINE_COLUMN=true */ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser; + +/** + * This exception is thrown when parse errors are encountered. + * You can explicitly create objects of this exception type by + * calling the method generateParseException in the generated + * parser. + * + * You can modify this class to customize your error reporting + * mechanisms so long as you retain the public fields. + */ +public class ParseException extends Exception { + + /** + * The version identifier for this Serializable class. + * Increment only if the serialized form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + private static final String INDENT = " "; + + /** + * The end of line string (we do not use System.getProperty("") so that we are compatible with Android/GWT); + */ + protected static String EOL = "\n"; + + + public ParseException(Token currentTokenVal, + int[][] expectedTokenSequencesVal, + String[] tokenImageVal + ) + { + this (currentTokenVal, expectedTokenSequencesVal, tokenImageVal, null); + } + + + /** + * This constructor is used by the method "generateParseException" + * in the generated parser. Calling this constructor generates + * a new object of this type with the fields "currentToken", + * "expectedTokenSequences", and "tokenImage" set. + */ + public ParseException(Token currentTokenVal, + int[][] expectedTokenSequencesVal, + String[] tokenImageVal, + String lexicalStateName + ) + { + super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal, lexicalStateName)); + currentToken = currentTokenVal; + expectedTokenSequences = expectedTokenSequencesVal; + tokenImage = tokenImageVal; + } + + /** + * The following constructors are for use by you for whatever + * purpose you can think of. Constructing the exception in this + * manner makes the exception behave in the normal way - i.e., as + * documented in the class "Throwable". The fields "errorToken", + * "expectedTokenSequences", and "tokenImage" do not contain + * relevant information. The JavaCC generated code does not use + * these constructors. + */ + + public ParseException() { + super(); + } + + /** Constructor with message. */ + public ParseException(String message) { + super(message); + } + + + /** + * This is the last token that has been consumed successfully. If + * this object has been created due to a parse error, the token + * followng this token will (therefore) be the first error token. + */ + public Token currentToken; + + /** + * Each entry in this array is an array of integers. Each array + * of integers represents a sequence of tokens (by their ordinal + * values) that is expected at this point of the parse. + */ + public int[][] expectedTokenSequences; + + /** + * This is a reference to the "tokenImage" array of the generated + * parser within which the parse error occurred. This array is + * defined in the generated ...Constants interface. + */ + public String[] tokenImage; + + /** + * It uses "currentToken" and "expectedTokenSequences" to generate a parse + * error message and returns it. If this object has been created + * due to a parse error, and you do not catch it (it gets thrown + * from the parser) the correct error message + * gets displayed. + */ + private static String initialise(Token currentToken, + int[][] expectedTokenSequences, + String[] tokenImage, + String lexicalStateName) { + StringBuilder sb = new StringBuilder(); + StringBuffer expected = new StringBuffer(); + + int maxSize = 0; + java.util.TreeSet sortedOptions = new java.util.TreeSet(); + for (int i = 0; i < expectedTokenSequences.length; i++) { + if (maxSize < expectedTokenSequences[i].length) { + maxSize = expectedTokenSequences[i].length; + } + for (int j = 0; j < expectedTokenSequences[i].length; j++) { + sortedOptions.add(tokenImage[expectedTokenSequences[i][j]]); + } + } + + for (String option : sortedOptions) { + expected.append(INDENT).append(option).append(EOL); + } + + sb.append("Encountered unexpected token:"); + + Token tok = currentToken.next; + for (int i = 0; i < maxSize; i++) { + String tokenText = tok.image; + String escapedTokenText = add_escapes(tokenText); + if (i != 0) { + sb.append(" "); + } + if (tok.kind == 0) { + sb.append(tokenImage[0]); + break; + } + sb.append(" \""); + sb.append(escapedTokenText); + sb.append("\""); + sb.append(" " + tokenImage[tok.kind]); + tok = tok.next; + } + sb.append(EOL).append(INDENT).append("at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn); + sb.append(".").append(EOL); + + if (expectedTokenSequences.length == 0) { + // Nothing to add here + } else { + int numExpectedTokens = expectedTokenSequences.length; + sb.append(EOL).append("Was expecting"+ (numExpectedTokens == 1 ? ":" : " one of:") + EOL + EOL); + sb.append(expected.toString()); + } + // 2013/07/30 --> Seems to be inaccurate as represents the readahead state, not the lexical state BEFORE the unknown token +// if (lexicalStateName != null) { +// sb.append(EOL).append("** Lexical State : ").append(lexicalStateName).append(EOL).append(EOL); +// } + + return sb.toString(); + } + + + /** + * Used to convert raw characters to their escaped version + * when these raw version cannot be used as part of an ASCII + * string literal. + */ + static String add_escapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + +} +/* JavaCC - OriginalChecksum=f4d1610e84d3d5884564259f96f1c24b (do not edit this line) */ diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/Provider.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/Provider.java new file mode 100644 index 000000000..6dcbfb3e8 --- /dev/null +++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/Provider.java @@ -0,0 +1,47 @@ +/* Generated By:JavaCC: Do not edit this line. Provider.java Version 7.0 */ +/* JavaCCOptions:KEEP_LINE_COLUMN=true */ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser; + + +import java.io.IOException; + +public interface Provider { + /** + * Reads characters into an array + * @param buffer Destination buffer + * @param offset Offset at which to start storing characters + * @param length The maximum possible number of characters to read + * @return The number of characters read, or -1 if all read + * @exception IOException + */ + public int read(char buffer[], int offset, int len) throws IOException; + + /** + * Closes the stream and releases any system resources associated with + * it. + * @exception IOException + */ + public void close() throws IOException; + +} +/* JavaCC - OriginalChecksum=2a9bd492caf4b9d28bb7522391baadbc (do not edit this line) */ diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/SimpleCharStream.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/SimpleCharStream.java new file mode 100644 index 000000000..8f2bd2295 --- /dev/null +++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/SimpleCharStream.java @@ -0,0 +1,419 @@ +/* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 7.0 */ +/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser; + +/** + * An implementation of interface CharStream, where the stream is assumed to + * contain only ASCII characters (without unicode processing). + */ + +public class SimpleCharStream +{ +/** Whether parser is static. */ + public static final boolean staticFlag = false; + int bufsize; + int available; + int tokenBegin; +/** Position in buffer. */ + public int bufpos = -1; + protected int bufline[]; + protected int bufcolumn[]; + + protected int column = 0; + protected int line = 1; + + protected boolean prevCharIsCR = false; + protected boolean prevCharIsLF = false; + + protected Provider inputStream; + + protected char[] buffer; + protected int maxNextCharInd = 0; + protected int inBuf = 0; + protected int tabSize = 1; + protected boolean trackLineColumn = true; + + public void setTabSize(int i) { tabSize = i; } + public int getTabSize() { return tabSize; } + + + + protected void ExpandBuff(boolean wrapAround) + { + char[] newbuffer = new char[bufsize + 2048]; + int newbufline[] = new int[bufsize + 2048]; + int newbufcolumn[] = new int[bufsize + 2048]; + + try + { + if (wrapAround) + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos); + bufcolumn = newbufcolumn; + + maxNextCharInd = (bufpos += (bufsize - tokenBegin)); + } + else + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + bufcolumn = newbufcolumn; + + maxNextCharInd = (bufpos -= tokenBegin); + } + } + catch (Throwable t) + { + throw new RuntimeException(t.getMessage()); + } + + + bufsize += 2048; + available = bufsize; + tokenBegin = 0; + } + + protected void FillBuff() throws java.io.IOException + { + if (maxNextCharInd == available) + { + if (available == bufsize) + { + if (tokenBegin > 2048) + { + bufpos = maxNextCharInd = 0; + available = tokenBegin; + } + else if (tokenBegin < 0) + bufpos = maxNextCharInd = 0; + else + ExpandBuff(false); + } + else if (available > tokenBegin) + available = bufsize; + else if ((tokenBegin - available) < 2048) + ExpandBuff(true); + else + available = tokenBegin; + } + + int i; + try { + if ((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1) + { + inputStream.close(); + throw new java.io.IOException(); + } + else + maxNextCharInd += i; + return; + } + catch(java.io.IOException e) { + --bufpos; + backup(0); + if (tokenBegin == -1) + tokenBegin = bufpos; + throw e; + } + } + +/** Start. */ + public char BeginToken() throws java.io.IOException + { + tokenBegin = -1; + char c = readChar(); + tokenBegin = bufpos; + + return c; + } + + protected void UpdateLineColumn(char c) + { + column++; + + if (prevCharIsLF) + { + prevCharIsLF = false; + line += (column = 1); + } + else if (prevCharIsCR) + { + prevCharIsCR = false; + if (c == '\n') + { + prevCharIsLF = true; + } + else + line += (column = 1); + } + + switch (c) + { + case '\r' : + prevCharIsCR = true; + break; + case '\n' : + prevCharIsLF = true; + break; + case '\t' : + column--; + column += (tabSize - (column % tabSize)); + break; + default : + break; + } + + bufline[bufpos] = line; + bufcolumn[bufpos] = column; + } + +/** Read a character. */ + public char readChar() throws java.io.IOException + { + if (inBuf > 0) + { + --inBuf; + + if (++bufpos == bufsize) + bufpos = 0; + + return buffer[bufpos]; + } + + if (++bufpos >= maxNextCharInd) + FillBuff(); + + char c = buffer[bufpos]; + + UpdateLineColumn(c); + return c; + } + + @Deprecated + /** + * @deprecated + * @see #getEndColumn + */ + + public int getColumn() { + return bufcolumn[bufpos]; + } + + @Deprecated + /** + * @deprecated + * @see #getEndLine + */ + + public int getLine() { + return bufline[bufpos]; + } + + /** Get token end column number. */ + public int getEndColumn() { + return bufcolumn[bufpos]; + } + + /** Get token end line number. */ + public int getEndLine() { + return bufline[bufpos]; + } + + /** Get token beginning column number. */ + public int getBeginColumn() { + return bufcolumn[tokenBegin]; + } + + /** Get token beginning line number. */ + public int getBeginLine() { + return bufline[tokenBegin]; + } + +/** Backup a number of characters. */ + public void backup(int amount) { + + inBuf += amount; + if ((bufpos -= amount) < 0) + bufpos += bufsize; + } + + /** Constructor. */ + public SimpleCharStream(Provider dstream, int startline, + int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + } + + /** Constructor. */ + public SimpleCharStream(Provider dstream, int startline, + int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + + /** Constructor. */ + public SimpleCharStream(Provider dstream) + { + this(dstream, 1, 1, 4096); + } + + /** Reinitialise. */ + public void ReInit(Provider dstream, int startline, + int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + if (buffer == null || buffersize != buffer.length) + { + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + } + prevCharIsLF = prevCharIsCR = false; + tokenBegin = inBuf = maxNextCharInd = 0; + bufpos = -1; + } + + /** Reinitialise. */ + public void ReInit(Provider dstream, int startline, + int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + + /** Reinitialise. */ + public void ReInit(Provider dstream) + { + ReInit(dstream, 1, 1, 4096); + } + + + /** Get token literal value. */ + public String GetImage() + { + if (bufpos >= tokenBegin) + return new String(buffer, tokenBegin, bufpos - tokenBegin + 1); + else + return new String(buffer, tokenBegin, bufsize - tokenBegin) + + new String(buffer, 0, bufpos + 1); + } + + /** Get the suffix. */ + public char[] GetSuffix(int len) + { + char[] ret = new char[len]; + + if ((bufpos + 1) >= len) + System.arraycopy(buffer, bufpos - len + 1, ret, 0, len); + else + { + System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0, + len - bufpos - 1); + System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1); + } + + return ret; + } + + /** Reset buffer when finished. */ + public void Done() + { + buffer = null; + bufline = null; + bufcolumn = null; + } + + /** + * Method to adjust line and column numbers for the start of a token. + */ + public void adjustBeginLineColumn(int newLine, int newCol) + { + int start = tokenBegin; + int len; + + if (bufpos >= tokenBegin) + { + len = bufpos - tokenBegin + inBuf + 1; + } + else + { + len = bufsize - tokenBegin + bufpos + 1 + inBuf; + } + + int i = 0, j = 0, k = 0; + int nextColDiff = 0, columnDiff = 0; + + while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize]) + { + bufline[j] = newLine; + nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j]; + bufcolumn[j] = newCol + columnDiff; + columnDiff = nextColDiff; + i++; + } + + if (i < len) + { + bufline[j] = newLine++; + bufcolumn[j] = newCol + columnDiff; + + while (i++ < len) + { + if (bufline[j = start % bufsize] != bufline[++start % bufsize]) + bufline[j] = newLine++; + else + bufline[j] = newLine; + } + } + + line = bufline[j]; + column = bufcolumn[j]; + } + boolean getTrackLineColumn() { return trackLineColumn; } + void setTrackLineColumn(boolean tlc) { trackLineColumn = tlc; } +} +/* JavaCC - OriginalChecksum=426048510a1ecd9a28c73d4def7423eb (do not edit this line) */ diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/StreamProvider.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/StreamProvider.java new file mode 100644 index 000000000..b3b3416ca --- /dev/null +++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/StreamProvider.java @@ -0,0 +1,78 @@ +/* Generated By:JavaCC: Do not edit this line. StreamProvider.java Version 7.0 */ +/* JavaCCOptions:KEEP_LINE_COLUMN=true */ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser; + + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; + +/** + * NOTE : This generated class can be safely deleted if installing in a GWT installation (use StringProvider instead) + */ +public class StreamProvider implements Provider { + + Reader _reader; + + public StreamProvider(Reader reader) { + _reader = reader; + } + + public StreamProvider(InputStream stream) throws IOException { + _reader = new BufferedReader(new InputStreamReader(stream)); + } + + public StreamProvider(InputStream stream, String charsetName) throws IOException { + _reader = new BufferedReader(new InputStreamReader(stream, charsetName)); + } + + @Override + public int read(char[] buffer, int off, int len) throws IOException { + int result = _reader.read(buffer, off, len); + + /* CBA -- Added 2014/03/29 -- + This logic allows the generated Java code to be easily translated to C# (via sharpen) - + as in C# 0 represents end of file, and in Java, -1 represents end of file + See : http://msdn.microsoft.com/en-us/library/9kstw824(v=vs.110).aspx + ** Technically, this is not required for java but the overhead is extremely low compared to the code generation benefits. + */ + + if (result == 0) { + if (off < buffer.length && len > 0) { + result = -1; + } + } + + return result; + } + + @Override + public void close() throws IOException { + _reader.close(); + } + +} + +/* JavaCC - OriginalChecksum=bc0ddea608a1ea01a8e32fee4c628d00 (do not edit this line) */ diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/StringProvider.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/StringProvider.java new file mode 100644 index 000000000..14c7d6dd1 --- /dev/null +++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/StringProvider.java @@ -0,0 +1,68 @@ +/* Generated By:JavaCC: Do not edit this line. StringProvider.java Version 7.0 */ +/* JavaCCOptions:KEEP_LINE_COLUMN=true */ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser; + + + import java.io.IOException; + + public class StringProvider implements Provider { + + String _string; + int _position = 0; + int _size; + + public StringProvider(String string) { + _string = string; + _size = string.length(); + } + + @Override + public int read(char[] cbuf, int off, int len) throws IOException { + int numCharsOutstandingInString = _size - _position; + + if (numCharsOutstandingInString == 0) { + return -1; + } + + int numBytesInBuffer = cbuf.length; + int numBytesToRead = numBytesInBuffer -off; + numBytesToRead = numBytesToRead > len ? len : numBytesToRead; + + if (numBytesToRead > numCharsOutstandingInString) { + numBytesToRead = numCharsOutstandingInString; + } + + _string.getChars(_position, _position + numBytesToRead, cbuf, off); + + _position += numBytesToRead; + + return numBytesToRead; + } + + @Override + public void close() throws IOException { + _string = null; + } + + } +/* JavaCC - OriginalChecksum=38052dc5b81585946987664a01065e9e (do not edit this line) */ diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/Token.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/Token.java new file mode 100644 index 000000000..b8764d415 --- /dev/null +++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/Token.java @@ -0,0 +1,152 @@ +/* Generated By:JavaCC: Do not edit this line. Token.java Version 7.0 */ +/* JavaCCOptions:TOKEN_EXTENDS=TokenBase,KEEP_LINE_COLUMN=true,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser; + +/** + * Describes the input token stream. + */ + +public class Token extends TokenBase implements java.io.Serializable { + + /** + * The version identifier for this Serializable class. + * Increment only if the serialized form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + /** + * An integer that describes the kind of this token. This numbering + * system is determined by JavaCCParser, and a table of these numbers is + * stored in the file ...Constants.java. + */ + public int kind; + + /** The line number of the first character of this Token. */ + public int beginLine; + /** The column number of the first character of this Token. */ + public int beginColumn; + /** The line number of the last character of this Token. */ + public int endLine; + /** The column number of the last character of this Token. */ + public int endColumn; + + /** + * The string image of the token. + */ + public String image; + + /** + * A reference to the next regular (non-special) token from the input + * stream. If this is the last token from the input stream, or if the + * token manager has not read tokens beyond this one, this field is + * set to null. This is true only if this token is also a regular + * token. Otherwise, see below for a description of the contents of + * this field. + */ + public Token next; + + /** + * This field is used to access special tokens that occur prior to this + * token, but after the immediately preceding regular (non-special) token. + * If there are no such special tokens, this field is set to null. + * When there are more than one such special token, this field refers + * to the last of these special tokens, which in turn refers to the next + * previous special token through its specialToken field, and so on + * until the first special token (whose specialToken field is null). + * The next fields of special tokens refer to other special tokens that + * immediately follow it (without an intervening regular token). If there + * is no such token, this field is null. + */ + public Token specialToken; + + /** + * An optional attribute value of the Token. + * Tokens which are not used as syntactic sugar will often contain + * meaningful values that will be used later on by the compiler or + * interpreter. This attribute value is often different from the image. + * Any subclass of Token that actually wants to return a non-null value can + * override this method as appropriate. + */ + public Object getValue() { + return null; + } + + /** + * No-argument constructor + */ + public Token() {} + + /** + * Constructs a new token for the specified Image. + */ + public Token(int kind) + { + this(kind, null); + } + + /** + * Constructs a new token for the specified Image and Kind. + */ + public Token(int kind, String image) + { + this.kind = kind; + this.image = image; + } + + /** + * Returns the image. + */ + @Override + public String toString() + { + return image; + } + + /** + * Returns a new Token object, by default. However, if you want, you + * can create and return subclass objects based on the value of ofKind. + * Simply add the cases to the switch for all those special cases. + * For example, if you have a subclass of Token called IDToken that + * you want to create if ofKind is ID, simply add something like : + * + * case MyParserConstants.ID : return new IDToken(ofKind, image); + * + * to the following switch statement. Then you can cast matchedToken + * variable to the appropriate type and use sit in your lexical actions. + */ + public static Token newToken(int ofKind, String image) + { + switch(ofKind) + { + default : return new Token(ofKind, image); + } + } + + public static Token newToken(int ofKind) + { + return newToken(ofKind, null); + } + +} +/* JavaCC - OriginalChecksum=4dee3ecb0b873195e388b52791f0170e (do not edit this line) */ diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/TokenMgrException.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/TokenMgrException.java new file mode 100644 index 000000000..a34079b7a --- /dev/null +++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/TokenMgrException.java @@ -0,0 +1,167 @@ +/* Generated By:JavaCC: Do not edit this line. TokenMgrException.java Version 7.0 */ +/* JavaCCOptions: */ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser; + +/** Token Manager Error. */ +public class TokenMgrException extends RuntimeException +{ + + /** + * The version identifier for this Serializable class. + * Increment only if the serialized form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + /* + * Ordinals for various reasons why an Error of this type can be thrown. + */ + + /** + * Lexical error occurred. + */ + public static final int LEXICAL_ERROR = 0; + + /** + * An attempt was made to create a second instance of a static token manager. + */ + public static final int STATIC_LEXER_ERROR = 1; + + /** + * Tried to change to an invalid lexical state. + */ + public static final int INVALID_LEXICAL_STATE = 2; + + /** + * Detected (and bailed out of) an infinite loop in the token manager. + */ + public static final int LOOP_DETECTED = 3; + + /** + * Indicates the reason why the exception is thrown. It will have + * one of the above 4 values. + */ + int errorCode; + + /** + * Replaces unprintable characters by their escaped (or unicode escaped) + * equivalents in the given string + */ + protected static final String addEscapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + + /** + * Returns a detailed message for the Error when it is thrown by the + * token manager to indicate a lexical error. + * Parameters : + * EOFSeen : indicates if EOF caused the lexical error + * curLexState : lexical state in which this error occurred + * errorLine : line number when the error occurred + * errorColumn : column number when the error occurred + * errorAfter : prefix that was seen before this error occurred + * curchar : the offending character + * Note: You can customize the lexical error message by modifying this method. + */ + protected static String LexicalErr(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, int curChar) { + char curChar1 = (char)curChar; + return("Lexical error at line " + + errorLine + ", column " + + errorColumn + ". Encountered: " + + (EOFSeen ? " " : ("\"" + addEscapes(String.valueOf(curChar1)) + "\"") + " (" + curChar + "), ") + + "after : \"" + addEscapes(errorAfter) + "\""); + } + + /** + * You can also modify the body of this method to customize your error messages. + * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not + * of end-users concern, so you can return something like : + * + * "Internal Error : Please file a bug report .... " + * + * from this method for such cases in the release version of your parser. + */ + @Override + public String getMessage() { + return super.getMessage(); + } + + /* + * Constructors of various flavors follow. + */ + + /** No arg constructor. */ + public TokenMgrException() { + } + + /** Constructor with message and reason. */ + public TokenMgrException(String message, int reason) { + super(message); + errorCode = reason; + } + + /** Full Constructor. */ + public TokenMgrException(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, int curChar, int reason) { + this(LexicalErr(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason); + } +} +/* JavaCC - OriginalChecksum=a12f92ff78a572ce135bdb1f55ed69c1 (do not edit this line) */ -- cgit v1.2.3