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