Add java_library to Android.bp and manually generated_sources.
Bug: 262898801
Test: mma
Change-Id: I568083b350be298d38aa9791cbfa24b4ad99f9e0
diff --git a/Android.bp b/Android.bp
index 149a5a3..1415c07 100644
--- a/Android.bp
+++ b/Android.bp
@@ -28,3 +28,38 @@
"NOTICE",
],
}
+
+java_library {
+ name: "apache-velocity-engine-core",
+ srcs: ["velocity-engine-core/src/main/java/**/*.java",
+ // Manually generated code as javacc is not availiable for AOSP build
+ // mvn && cp -r velocity-engine-core/target/generated-srcs .
+ "generated-sources/**/*.java"],
+ exclude_srcs: ["velocity-engine-core/src/main/java/org/apache/velocity/runtime/resource/loader/JarResourceLoader.java",
+ "velocity-engine-core/src/main/java/org/apache/velocity/runtime/resource/loader/DataSourceResourceLoader.java"],
+ java_resource_dirs: ["velocity-engine-core/src/main/resources"],
+ sdk_version: "current",
+ min_sdk_version: "33",
+ static_libs: [
+ "apache-commons-lang",
+ "apache-commons-io",
+ "slf4j-jdk14",
+ ],
+ java_version: "1.8",
+ apex_available: [
+ "//apex_available:platform",
+ "com.android.ondevicepersonalization",
+ ],
+ visibility: [
+ "//external/apache-velocity-engine",
+ "//packages/modules/OnDevicePersonalization:__subpackages__",
+ ],
+ lint: {
+ warning_checks: ["SuspiciousIndentation"],
+ },
+ errorprone: {
+ javacflags: [
+ "-Xep:ReturnValueIgnored:OFF",
+ ],
+ },
+}
diff --git a/generated-sources/java-templates/org/apache/velocity/runtime/VelocityEngineVersion.java b/generated-sources/java-templates/org/apache/velocity/runtime/VelocityEngineVersion.java
new file mode 100644
index 0000000..55d9cac
--- /dev/null
+++ b/generated-sources/java-templates/org/apache/velocity/runtime/VelocityEngineVersion.java
@@ -0,0 +1,6 @@
+package org.apache.velocity.runtime;
+
+public class VelocityEngineVersion
+{
+ public static final String VERSION = "2.4-SNAPSHOT";
+}
diff --git a/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParser.java b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParser.java
new file mode 100644
index 0000000..1e857d8
--- /dev/null
+++ b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParser.java
@@ -0,0 +1,5447 @@
+/* Generated By:JJTree&JavaCC: Do not edit this line. StandardParser.java */
+package org.apache.velocity.runtime.parser;
+import org.apache.velocity.runtime.parser.node.*;
+
+
+import java.io.*;
+import java.util.*;
+import org.apache.velocity.Template;
+import org.apache.velocity.exception.VelocityException;
+import org.apache.velocity.runtime.RuntimeServices;
+import org.apache.velocity.runtime.parser.*;
+import org.apache.velocity.runtime.parser.node.*;
+import org.apache.velocity.runtime.directive.*;
+import org.apache.velocity.runtime.directive.MacroParseException;
+import org.apache.velocity.runtime.RuntimeConstants;
+import static org.apache.velocity.runtime.RuntimeConstants.SpaceGobbling;
+
+import org.slf4j.Logger;
+
+/**
+ * This class is responsible for parsing a Velocity
+ * template. This class was generated by JavaCC using
+ * the JJTree extension to produce an Abstract
+ * Syntax Tree (AST) of the template.
+ *
+ * Please look at the Parser.jjt file which is
+ * what controls the generation of this class.
+ *
+ * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
+ * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
+ * @author <a href="hps@intermeta.de">Henning P. Schmiedehausen</a>
+ * @version $Id$
+*/
+public class StandardParser implements/*@bgen(jjtree)*/ StandardParserTreeConstants,Parser, StandardParserConstants {/*@bgen(jjtree)*/
+ protected JJTStandardParserState jjtree = new JJTStandardParserState();/**
+ * Parser debugging flag.
+ * When debug is active, javacc Parser will contain (among other things)
+ * a trace_call() method. So we use the presence of this method to
+ * initialize our flag.
+ */
+ private static boolean debugParser;
+ static
+ {
+ try
+ {
+ StandardParser.class.getDeclaredMethod("trace_call", String.class);
+ debugParser = true;
+ }
+ catch(NoSuchMethodException nsfe)
+ {
+ debugParser = false;
+ }
+ }
+
+ /**
+ * Our own trace method. Use sparsingly in production, since each
+ * and every call will introduce an execution branch and slow down parsing.
+ */
+ public static void trace(String message)
+ {
+ if (debugParser) System.out.println(message);
+ }
+
+ /**
+ * Keep track of defined macros, used for escape processing
+ */
+ private Map macroNames = new HashMap();
+
+ /**
+ * Current template we are parsing. Passed to us in parse()
+ */
+ public Template currentTemplate = null;
+
+ /**
+ * Set to true if the property
+ * RuntimeConstants.RUNTIME_REFERENCES_STRICT_ESCAPE is set to true
+ */
+ public boolean strictEscape = false;
+
+ /**
+ * Set to true if the propoerty
+ * RuntimeConstants.PARSER_HYPHEN_ALLOWED is set to true
+ */
+ public boolean hyphenAllowedInIdentifiers = false;
+
+ VelocityCharStream velcharstream = null;
+
+ private RuntimeServices rsvc = null;
+
+ @Override
+ public RuntimeServices getRuntimeServices()
+ {
+ return rsvc;
+ }
+
+ private Logger log = null;
+
+ /**
+ * This constructor was added to allow the re-use of parsers.
+ * The normal constructor takes a single argument which
+ * an InputStream. This simply creates a re-usable parser
+ * object, we satisfy the requirement of an InputStream
+ * by using a newline character as an input stream.
+ */
+ public StandardParser( RuntimeServices rs)
+ {
+ /*
+ * need to call the CTOR first thing.
+ */
+
+ this( new VelocityCharStream(
+ new ByteArrayInputStream("\u005cn".getBytes()), 1, 1 ));
+
+ /*
+ * then initialize logger
+ */
+
+ log = rs.getLog("parser");
+
+
+ /*
+ * now setup a VCS for later use
+ */
+ velcharstream = new VelocityCharStream(
+ new ByteArrayInputStream("\u005cn".getBytes()), 1, 1 );
+
+
+ strictEscape =
+ rs.getBoolean(RuntimeConstants.RUNTIME_REFERENCES_STRICT_ESCAPE, false);
+
+ hyphenAllowedInIdentifiers =
+ rs.getBoolean(RuntimeConstants.PARSER_HYPHEN_ALLOWED, false);
+
+ /*
+ * and save the RuntimeServices
+ */
+ rsvc = rs;
+
+ /*
+ * then initialize customizable characters
+ */
+ dollar = '$';
+ hash = '#';
+ at = '@';
+ asterisk = '*';
+ }
+
+ /**
+ * This was also added to allow parsers to be
+ * re-usable. Normal JavaCC use entails passing an
+ * input stream to the constructor and the parsing
+ * process is carried out once. We want to be able
+ * to re-use parsers: we do this by adding this
+ * method and re-initializing the lexer with
+ * the new stream that we want parsed.
+ */
+ @Override
+ public SimpleNode parse( Reader reader, Template template )
+ throws ParseException
+ {
+ SimpleNode sn = null;
+
+ currentTemplate = template;
+
+ try
+ {
+ token_source.clearStateVars();
+
+ /*
+ * reinitialize the VelocityCharStream
+ * with the new reader
+ */
+ velcharstream.ReInit( reader, 1, 1 );
+
+ /*
+ * now reinit the Parser with this CharStream
+ */
+ ReInit( velcharstream );
+
+ /*
+ * do that voodoo...
+ */
+ sn = process();
+ }
+ catch (MacroParseException mee)
+ {
+ /*
+ * thrown by the Macro class when something is amiss in the
+ * Macro specification
+ */
+ log.error("{}: {}", template.getName(), mee.getMessage(), mee);
+ throw mee;
+ }
+ catch (ParseException pe)
+ {
+ log.error("{}: {}", currentTemplate.getName(), pe.getMessage());
+ throw new TemplateParseException (pe.currentToken,
+ pe.expectedTokenSequences, pe.tokenImage, currentTemplate.getName());
+ }
+ catch (TokenMgrError tme)
+ {
+ throw new ParseException("Lexical error: " + tme.toString());
+ }
+ catch (Exception e)
+ {
+ String msg = template.getName() + ": " + e.getMessage();
+ log.error(msg, e);
+ throw new VelocityException(msg, e, getRuntimeServices().getLogContext().getStackTrace());
+ }
+
+ currentTemplate = null;
+
+ return sn;
+ }
+
+ /**
+ * This method gets a Directive from the directives Hashtable
+ */
+ @Override
+ public Directive getDirective(String directive)
+ {
+ return (Directive) rsvc.getDirective(directive);
+ }
+
+ /**
+ * This method finds out of the directive exists in the directives Map.
+ */
+ @Override
+ public boolean isDirective(String directive)
+ {
+ return rsvc.getDirective(directive) != null;
+ }
+
+
+ /**
+ * Produces a processed output for an escaped control or
+ * pluggable directive
+ */
+ private String escapedDirective( String strImage )
+ {
+ int iLast = strImage.lastIndexOf("\u005c\u005c");
+
+ String strDirective = strImage.substring(iLast + 1);
+
+ boolean bRecognizedDirective = false;
+
+ // we don't have to call substring method all the time in this method
+ String dirTag = strDirective.substring(1);
+ if (dirTag.charAt(0) == '{')
+ {
+ dirTag = dirTag.substring(1, dirTag.length() - 1);
+ }
+
+ /*
+ * If this is a predefined derective or if we detect
+ * a macro definition (this is aproximate at best) then
+ * we absorb the forward slash. If in strict reference
+ * mode then we always absord the forward slash regardless
+ * if the derective is defined or not.
+ */
+
+ if (strictEscape
+ || isDirective(dirTag)
+ || macroNames.containsKey(dirTag)
+ || rsvc.isVelocimacro(dirTag, currentTemplate))
+ {
+ bRecognizedDirective = true;
+ }
+ else
+ {
+ /* order for speed? */
+
+ if ( dirTag.equals("if")
+ || dirTag.equals("end")
+ || dirTag.equals("set")
+ || dirTag.equals("else")
+ || dirTag.equals("elseif")
+ )
+ {
+ bRecognizedDirective = true;
+ }
+ }
+
+ /*
+ * if so, make the proper prefix string (let the escapes do their thing..)
+ * otherwise, just return what it is..
+ */
+
+ if (bRecognizedDirective)
+ return ( strImage.substring(0,iLast/2) + strDirective);
+ else
+ return ( strImage );
+ }
+
+ /**
+ * Check whether there is a left parenthesis with leading optional
+ * whitespaces. This method is used in the semantic look ahead of
+ * Directive method. This is done in code instead of as a production
+ * for simplicity and efficiency.
+ */
+ private boolean isLeftParenthesis()
+ {
+ char c;
+ int no = 0;
+ try {
+ while(true)
+ {
+ /**
+ * Read a character
+ */
+ c = velcharstream.readChar();
+ no++;
+ if (c == '(')
+ {
+ return true;
+ }
+ /**
+ * if not a white space return
+ */
+ else if (c != ' ' && c != '\u005cn' && c != '\u005cr' && c != '\u005ct')
+ {
+ return false;
+ }
+ }
+ }
+ catch(IOException e)
+ {
+ }
+ finally
+ {
+ /**
+ * Backup the stream to the initial state
+ */
+ velcharstream.backup(no);
+ }
+ return false;
+ }
+
+ /**
+ * Check whether there is a right parenthesis with leading optional
+ * whitespaces. This method is used in the semantic look ahead of
+ * Directive method. This is done in code instead of as a production
+ * for simplicity and efficiency.
+ */
+ private boolean isRightParenthesis()
+ {
+ char c;
+ int no = -1;
+ try {
+ while(true)
+ {
+ /**
+ * Read a character
+ */
+ if (no == -1)
+ {
+ switch (getToken(1).kind)
+ {
+ case RPAREN:
+ return true;
+ case WHITESPACE:
+ case NEWLINE:
+ no = 0;
+ break;
+ default:
+ return false;
+ }
+ }
+ c = velcharstream.readChar();
+ no++;
+ if (c == ')')
+ {
+ return true;
+ }
+ /**
+ * if not a white space return
+ */
+ else if (c != ' ' && c != '\u005cn' && c != '\u005cr' && c != '\u005ct')
+ {
+ return false;
+ }
+ }
+ }
+ catch(IOException e)
+ {
+ }
+ finally
+ {
+ /**
+ * Backup the stream to the initial state
+ */
+ if (no > 0) velcharstream.backup(no);
+ }
+ return false;
+ }
+
+ /**
+ * We use this method in a lookahead to determine if we are in a macro
+ * default value assignment. The standard lookahead is not smart enough.
+ * here we look for the equals after the reference.
+ */
+ private boolean isAssignment()
+ {
+ // Basically if the last character read was not '$' then false
+ if (token_source.getCurrentLexicalState() != REFERENCE) return false;
+
+ char c = ' ';
+ int backup = 0;
+ try
+ {
+ // Read through any white space
+ while(Character.isWhitespace(c))
+ {
+ c = velcharstream.readChar();
+ backup++;
+ }
+
+ // This is what we are ultimately looking for
+ if (c != '=') return false;
+ }
+ catch (IOException e)
+ {
+ }
+ finally
+ {
+ velcharstream.backup(backup);
+ }
+
+ return true;
+ }
+
+ @Override
+ public Template getCurrentTemplate()
+ {
+ return currentTemplate;
+ }
+
+ @Override
+ public void resetCurrentTemplate()
+ {
+ currentTemplate = null;
+ }
+
+ @Override
+ public char dollar()
+ {
+ return dollar;
+ }
+
+ @Override
+ public char hash()
+ {
+ return hash;
+ }
+
+ @Override
+ public char at()
+ {
+ return at;
+ }
+
+ @Override
+ public char asterisk()
+ {
+ return asterisk;
+ }
+
+ private char dollar = '$';
+ private char hash = '#';
+ private char at = '@';
+ private char asterisk = '*';
+
+/**
+ * This method is what starts the whole parsing
+ * process. After the parsing is complete and
+ * the template has been turned into an AST,
+ * this method returns the root of AST which
+ * can subsequently be traversed by a visitor
+ * which implements the ParserVisitor interface
+ * which is generated automatically by JavaCC
+ */
+ final public SimpleNode process() throws ParseException {
+ /*@bgen(jjtree) process */
+ ASTprocess jjtn000 = new ASTprocess(this, JJTPROCESS);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);boolean afterNewline = true;
+ try {
+ label_1:
+ while (true) {
+ if (getToken(1).kind != EOF) {
+ ;
+ } else {
+ break label_1;
+ }
+ afterNewline = Statement(afterNewline);
+ }
+ jj_consume_token(0);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return jjtn000;}
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+/**
+ * These are the types of statements that
+ * are acceptable in Velocity templates.
+ */
+ final public boolean Statement(boolean afterNewline) throws ParseException {
+ if (getToken(1).kind == IF_DIRECTIVE || afterNewline && getToken(1).kind == WHITESPACE && getToken(2).kind == IF_DIRECTIVE) {
+ afterNewline = IfStatement(afterNewline);
+ {if (true) return afterNewline;}
+ } else if (jj_2_1(2)) {
+ Reference();
+ {if (true) return false;}
+ } else if (jj_2_2(2)) {
+ afterNewline = Comment();
+ {if (true) return afterNewline;}
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case TEXTBLOCK:
+ Textblock();
+ {if (true) return false;}
+ break;
+ default:
+ jj_la1[1] = jj_gen;
+ if (getToken(1).kind == SET_DIRECTIVE || afterNewline && getToken(1).kind == WHITESPACE && getToken(2).kind == SET_DIRECTIVE) {
+ afterNewline = SetDirective(afterNewline);
+ {if (true) return afterNewline;}
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case ESCAPE_DIRECTIVE:
+ EscapedDirective();
+ {if (true) return false;}
+ break;
+ case DOUBLE_ESCAPE:
+ Escape();
+ {if (true) return false;}
+ break;
+ default:
+ jj_la1[2] = jj_gen;
+ if (getToken(1).kind == WORD || getToken(1).kind == BRACKETED_WORD || afterNewline && getToken(1).kind == WHITESPACE && ( getToken(2).kind == WORD || getToken(2).kind == BRACKETED_WORD )) {
+ afterNewline = Directive(afterNewline);
+ {if (true) return afterNewline;}
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LONE_SYMBOL:
+ case PIPE:
+ case LPAREN:
+ case RPAREN:
+ case STRING_LITERAL:
+ case INTEGER_LITERAL:
+ case FLOATING_POINT_LITERAL:
+ case DOT:
+ case LCURLY:
+ case RCURLY:
+ case ESCAPE:
+ case TEXT:
+ case EMPTY_INDEX:
+ afterNewline = Text();
+ {if (true) return afterNewline;}
+ break;
+ case NEWLINE:
+ ASTText jjtn001 = new ASTText(this, JJTTEXT);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ jj_consume_token(NEWLINE);
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, true);
+ }
+ }
+ {if (true) return true;}
+ break;
+ case INLINE_TEXT:
+ ASTText jjtn002 = new ASTText(this, JJTTEXT);
+ boolean jjtc002 = true;
+ jjtree.openNodeScope(jjtn002);
+ try {
+ jj_consume_token(INLINE_TEXT);
+ afterNewline = false;
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case TEXT:
+ jj_consume_token(TEXT);
+ afterNewline = true;
+ break;
+ default:
+ jj_la1[0] = jj_gen;
+ ;
+ }
+ } finally {
+ if (jjtc002) {
+ jjtree.closeNodeScope(jjtn002, true);
+ }
+ }
+ {if (true) return afterNewline;}
+ break;
+ case WHITESPACE:
+ ASTText jjtn003 = new ASTText(this, JJTTEXT);
+ boolean jjtc003 = true;
+ jjtree.openNodeScope(jjtn003);
+ try {
+ jj_consume_token(WHITESPACE);
+ } finally {
+ if (jjtc003) {
+ jjtree.closeNodeScope(jjtn003, true);
+ }
+ }
+ {if (true) return false;}
+ break;
+ case SUFFIX:
+ ASTText jjtn004 = new ASTText(this, JJTTEXT);
+ boolean jjtc004 = true;
+ jjtree.openNodeScope(jjtn004);
+ try {
+ jj_consume_token(SUFFIX);
+ } finally {
+ if (jjtc004) {
+ jjtree.closeNodeScope(jjtn004, true);
+ }
+ }
+ {if (true) return true;}
+ break;
+ default:
+ jj_la1[3] = jj_gen;
+ if (jj_2_3(2)) {
+ EndingZeroWidthWhitespace();
+ {if (true) return afterNewline;}
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LOGICAL_OR_2:
+ ASTText jjtn005 = new ASTText(this, JJTTEXT);
+ boolean jjtc005 = true;
+ jjtree.openNodeScope(jjtn005);
+ try {
+ jj_consume_token(LOGICAL_OR_2);
+ } finally {
+ if (jjtc005) {
+ jjtree.closeNodeScope(jjtn005, true);
+ }
+ }
+ {if (true) return afterNewline;}
+ break;
+ case ZERO_WIDTH_WHITESPACE:
+ ASTText jjtn006 = new ASTText(this, JJTTEXT);
+ boolean jjtc006 = true;
+ jjtree.openNodeScope(jjtn006);
+ try {
+ jj_consume_token(ZERO_WIDTH_WHITESPACE);
+ } finally {
+ if (jjtc006) {
+ jjtree.closeNodeScope(jjtn006, true);
+ }
+ }
+ afterNewline = !afterNewline; {if (true) return false;}
+ break;
+ default:
+ jj_la1[4] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public void EndingZeroWidthWhitespace() throws ParseException {
+ jj_consume_token(ZERO_WIDTH_WHITESPACE);
+ jj_consume_token(0);
+
+ }
+
+/**
+ * used to separate the notion of a valid directive that has been
+ * escaped, versus something that looks like a directive and
+ * is just schmoo. This is important to do as a separate production
+ * that creates a node, because we want this, in either case, to stop
+ * the further parsing of the Directive() tree.
+ */
+ final public void EscapedDirective() throws ParseException {
+ /*@bgen(jjtree) EscapedDirective */
+ ASTEscapedDirective jjtn000 = new ASTEscapedDirective(this, JJTESCAPEDDIRECTIVE);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ Token t = null;
+ t = jj_consume_token(ESCAPE_DIRECTIVE);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ /*
+ * churn and burn..
+ */
+ t.image = escapedDirective( t.image );
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+/**
+ * Used to catch and process escape sequences in grammatical constructs
+ * as escapes outside of VTL are just characters. Right now we have both
+ * this and the EscapeDirective() construction because in the EscapeDirective()
+ * case, we want to suck in the #<directive> and here we don't. We just want
+ * the escapes to render correctly
+ */
+ final public void Escape() throws ParseException {
+ /*@bgen(jjtree) Escape */
+ ASTEscape jjtn000 = new ASTEscape(this, JJTESCAPE);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ Token t = null;
+ int count = 0;
+ boolean control = false;
+ label_2:
+ while (true) {
+ t = jj_consume_token(DOUBLE_ESCAPE);
+ count++;
+ if (jj_2_4(2)) {
+ ;
+ } else {
+ break label_2;
+ }
+ }
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ /*
+ * first, check to see if we have a control directive
+ */
+ switch(t.next.kind ) {
+ case IF_DIRECTIVE :
+ case ELSE :
+ case ELSEIF :
+ case END :
+ control = true;
+ break;
+ }
+
+ /*
+ * if that failed, lets lookahead to see if we matched a PD or a VM
+ */
+ String nTag = t.next.image.substring(1);
+ if (strictEscape
+ || isDirective(nTag)
+ || macroNames.containsKey(nTag)
+ || rsvc.isVelocimacro(nTag, currentTemplate))
+ {
+ control = true;
+ }
+
+ jjtn000.val = "";
+
+ for( int i = 0; i < count; i++)
+ jjtn000.val += ( control ? "\u005c\u005c" : "\u005c\u005c\u005c\u005c");
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public boolean Comment() throws ParseException {
+ /*@bgen(jjtree) Comment */
+ ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case SINGLE_LINE_COMMENT_START:
+ jj_consume_token(SINGLE_LINE_COMMENT_START);
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case SINGLE_LINE_COMMENT:
+ jj_consume_token(SINGLE_LINE_COMMENT);
+ break;
+ default:
+ jj_la1[5] = jj_gen;
+ ;
+ }
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return true;}
+ break;
+ case MULTI_LINE_COMMENT:
+ jj_consume_token(MULTI_LINE_COMMENT);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case FORMAL_COMMENT:
+ jj_consume_token(FORMAL_COMMENT);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ default:
+ jj_la1[6] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public void Textblock() throws ParseException {
+ /*@bgen(jjtree) Textblock */
+ ASTTextblock jjtn000 = new ASTTextblock(this, JJTTEXTBLOCK);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(TEXTBLOCK);
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public void FloatingPointLiteral() throws ParseException {
+ /*@bgen(jjtree) FloatingPointLiteral */
+ ASTFloatingPointLiteral jjtn000 = new ASTFloatingPointLiteral(this, JJTFLOATINGPOINTLITERAL);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(FLOATING_POINT_LITERAL);
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public void IntegerLiteral() throws ParseException {
+ /*@bgen(jjtree) IntegerLiteral */
+ ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(this, JJTINTEGERLITERAL);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(INTEGER_LITERAL);
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public void StringLiteral() throws ParseException {
+ /*@bgen(jjtree) StringLiteral */
+ ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(STRING_LITERAL);
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+/**
+ * This method corresponds to variable
+ * references in Velocity templates.
+ * The following are examples of variable
+ * references that may be found in a
+ * template:
+ *
+ * $foo
+ * $bar
+ *
+ */
+ final public void Identifier() throws ParseException {
+ /*@bgen(jjtree) Identifier */
+ ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ jj_consume_token(IDENTIFIER);
+ break;
+ case OLD_IDENTIFIER:
+ jj_consume_token(OLD_IDENTIFIER);
+ break;
+ default:
+ jj_la1[7] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public void Word() throws ParseException {
+ /*@bgen(jjtree) Word */
+ ASTWord jjtn000 = new ASTWord(this, JJTWORD);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(WORD);
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+/**
+ * Supports the arguments for the Pluggable Directives
+ */
+ final public int DirectiveArg() throws ParseException {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ case LCURLY:
+ Reference();
+ {if (true) return ParserTreeConstants.JJTREFERENCE;}
+ break;
+ case WORD:
+ Word();
+ {if (true) return ParserTreeConstants.JJTWORD;}
+ break;
+ case STRING_LITERAL:
+ StringLiteral();
+ {if (true) return ParserTreeConstants.JJTSTRINGLITERAL;}
+ break;
+ case INTEGER_LITERAL:
+ IntegerLiteral();
+ {if (true) return ParserTreeConstants.JJTINTEGERLITERAL;}
+ break;
+ default:
+ jj_la1[8] = jj_gen;
+ if (jj_2_5(2147483647)) {
+ IntegerRange();
+ {if (true) return ParserTreeConstants.JJTINTEGERRANGE;}
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case FLOATING_POINT_LITERAL:
+ FloatingPointLiteral();
+ {if (true) return ParserTreeConstants.JJTFLOATINGPOINTLITERAL;}
+ break;
+ case LEFT_CURLEY:
+ Map();
+ {if (true) return ParserTreeConstants.JJTMAP;}
+ break;
+ case LBRACKET:
+ ObjectArray();
+ {if (true) return ParserTreeConstants.JJTOBJECTARRAY;}
+ break;
+ case TRUE:
+ True();
+ {if (true) return ParserTreeConstants.JJTTRUE;}
+ break;
+ case FALSE:
+ False();
+ {if (true) return ParserTreeConstants.JJTFALSE;}
+ break;
+ default:
+ jj_la1[9] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public void DirectiveAssign() throws ParseException {
+ /*@bgen(jjtree) DirectiveAssign */
+ ASTDirectiveAssign jjtn000 = new ASTDirectiveAssign(this, JJTDIRECTIVEASSIGN);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ Reference();
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+/**
+ * Supports the Pluggable Directives
+ * #foo( arg+ )
+ * @return true if ends with a newline
+ */
+ final public boolean Directive(boolean afterNewline) throws ParseException {
+ /*@bgen(jjtree) Directive */
+ ASTDirective jjtn000 = new ASTDirective(this, JJTDIRECTIVE);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);Token id = null, t = null, u = null, end = null, _else = null;
+ int argType;
+ int argPos = 0;
+ Directive d;
+ int directiveType;
+ boolean isVM = false;
+ boolean isMacro = false;
+ ArrayList argtypes = new ArrayList(4);
+ String blockPrefix = "";
+ ASTBlock block = null, elseBlock = null;
+ boolean hasParentheses = false;
+ boolean newlineAtStart = afterNewline;
+ try {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ // only possible if not after new line
+ jjtn000.setPrefix(t.image);
+ t = null;
+ break;
+ default:
+ jj_la1[10] = jj_gen;
+ ;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WORD:
+ id = jj_consume_token(WORD);
+ break;
+ case BRACKETED_WORD:
+ id = jj_consume_token(BRACKETED_WORD);
+ break;
+ default:
+ jj_la1[11] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ String directiveName;
+ int p = id.image.lastIndexOf(hash);
+ if (id.kind == StandardParserConstants.BRACKETED_WORD)
+ {
+ directiveName = id.image.substring(p + 2, id.image.length() - 1);
+ }
+ else
+ {
+ directiveName = id.image.substring(p + 1);
+ }
+
+ d = getDirective(directiveName);
+
+ /*
+ * Velocimacro support : if the directive is macro directive
+ * then set the flag so after the block parsing, we add the VM
+ * right then. (So available if used w/in the current template )
+ */
+
+ if (directiveName.equals("macro"))
+ {
+ isMacro = true;
+ }
+
+ /*
+ * set the directive name from here. No reason for the thing to know
+ * about parser tokens
+ */
+
+ jjtn000.setDirectiveName(directiveName);
+
+ if ( d == null)
+ {
+ if( directiveName.charAt(0) == at )
+ {
+ // block macro call of type: #@foobar($arg1 $arg2) astBody #end
+ directiveType = Directive.BLOCK;
+ }
+ else
+ {
+ /*
+ * if null, then not a real directive, but maybe a Velocimacro
+ */
+ isVM = rsvc.isVelocimacro(directiveName, currentTemplate);
+
+ directiveType = Directive.LINE;
+ }
+ }
+ else
+ {
+ directiveType = d.getType();
+ }
+
+ /*
+ * now, switch us out of PRE_DIRECTIVE
+ */
+
+ token_source.switchTo(DIRECTIVE);
+ argPos = 0;
+ if (isLeftParenthesis()) {
+ label_3:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[12] = jj_gen;
+ break label_3;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[13] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ jj_consume_token(LPAREN);
+ label_4:
+ while (true) {
+ if (!isRightParenthesis()) {
+ ;
+ } else {
+ break label_4;
+ }
+ label_5:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[14] = jj_gen;
+ break label_5;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[15] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case COMMA:
+ jj_consume_token(COMMA);
+ label_6:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[16] = jj_gen;
+ break label_6;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[17] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ break;
+ default:
+ jj_la1[18] = jj_gen;
+ ;
+ }
+ if (jj_2_6(1)) {
+ if (isMacro && isAssignment()) {
+ DirectiveAssign();
+ label_7:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[19] = jj_gen;
+ break label_7;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[20] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ jj_consume_token(EQUALS);
+ label_8:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[21] = jj_gen;
+ break label_8;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[22] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ argtypes.add(ParserTreeConstants.JJTDIRECTIVEASSIGN);
+ } else {
+ ;
+ }
+ if (!isRightParenthesis()) {
+
+ } else {
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ argType = DirectiveArg();
+ argtypes.add(argType);
+ if (d == null && argType == ParserTreeConstants.JJTWORD)
+ {
+ if (isVM)
+ {
+ {if (true) throw new MacroParseException("Invalid argument "
+ + (argPos+1) + " in macro call " + id.image, currentTemplate.getName(), id);}
+ }
+ }
+ argPos++;
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case SINGLE_LINE_COMMENT_START:
+ if (!isMacro)
+ {
+ // We only allow line comments in macro definitions for now
+ {if (true) throw new MacroParseException("A Line comment is not allowed in " + id.image
+ + " arguments", currentTemplate.getName(), id);}
+ }
+ jj_consume_token(SINGLE_LINE_COMMENT_START);
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case SINGLE_LINE_COMMENT:
+ jj_consume_token(SINGLE_LINE_COMMENT);
+ break;
+ default:
+ jj_la1[23] = jj_gen;
+ ;
+ }
+ break;
+ default:
+ jj_la1[24] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+ label_9:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[25] = jj_gen;
+ break label_9;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[26] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ jj_consume_token(RPAREN);
+ hasParentheses = true;
+ } else {
+ token_source.stateStackPop();
+ }
+ afterNewline = false;
+ if (jj_2_7(2) && (directiveType != Directive.LINE || newlineAtStart && rsvc.getSpaceGobbling() != SpaceGobbling.BC || rsvc.getSpaceGobbling() == SpaceGobbling.BC && hasParentheses || d != null && (d instanceof Include || d instanceof Parse))) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ break;
+ default:
+ jj_la1[27] = jj_gen;
+ ;
+ }
+ u = jj_consume_token(NEWLINE);
+ afterNewline = true;
+ if (directiveType == Directive.LINE)
+ {
+ jjtn000.setPostfix(t == null ? u.image : t.image + u.image);
+ }
+ else
+ {
+ blockPrefix = (t == null ? u.image : t.image + u.image);
+ }
+ t = u = null;
+ } else {
+ ;
+ }
+ if (d != null)
+ {
+ d.checkArgs(argtypes, id, currentTemplate.getName());
+ }
+ if (directiveType == Directive.LINE)
+ {
+ {if (true) return afterNewline;}
+ }
+ ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ label_10:
+ while (true) {
+ if (getToken(1).kind != END && getToken(1).kind != ELSE && ( !afterNewline || getToken(1).kind != WHITESPACE || getToken(2).kind != END && getToken(2).kind != ELSE )) {
+ ;
+ } else {
+ break label_10;
+ }
+ afterNewline = Statement(afterNewline);
+ }
+ jjtree.closeNodeScope(jjtn001, true);
+ jjtc001 = false;
+ block = jjtn001;
+ block.setPrefix(blockPrefix);
+ blockPrefix = "";
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, true);
+ }
+ }
+ if (jj_2_8(1) && (afterNewline)) {
+ t = jj_consume_token(WHITESPACE);
+ block.setPostfix(t.image);
+ t = null;
+ } else {
+ ;
+ }
+ if (d != null && (d instanceof Foreach) && getToken(1).kind == ELSE) {
+ _else = jj_consume_token(ELSE);
+ ASTBlock jjtn002 = new ASTBlock(this, JJTBLOCK);
+ boolean jjtc002 = true;
+ jjtree.openNodeScope(jjtn002);
+ try {
+ if (jj_2_9(2)) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ break;
+ default:
+ jj_la1[28] = jj_gen;
+ ;
+ }
+ u = jj_consume_token(NEWLINE);
+ jjtn002.setPrefix(t == null ? u.image : t.image + u.image);
+ t = u = null;
+ afterNewline = true;
+ } else {
+ ;
+ }
+ label_11:
+ while (true) {
+ if (getToken(1).kind != END && (!afterNewline || getToken(1).kind != WHITESPACE || getToken(2).kind != END)) {
+ ;
+ } else {
+ break label_11;
+ }
+ afterNewline = Statement(afterNewline);
+ }
+ jjtree.closeNodeScope(jjtn002, true);
+ jjtc002 = false;
+ elseBlock = jjtn002;
+ } catch (Throwable jjte002) {
+ if (jjtc002) {
+ jjtree.clearNodeScope(jjtn002);
+ jjtc002 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte002 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte002;}
+ }
+ if (jjte002 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte002;}
+ }
+ {if (true) throw (Error)jjte002;}
+ } finally {
+ if (jjtc002) {
+ jjtree.closeNodeScope(jjtn002, true);
+ }
+ }
+ int pos = _else.image.lastIndexOf(hash);
+ if (pos > 0)
+ {
+ block.setMorePostfix(_else.image.substring(0, pos));
+ }
+ block = elseBlock;
+ } else {
+ ;
+ }
+ if (jj_2_10(1) && (afterNewline)) {
+ t = jj_consume_token(WHITESPACE);
+ block.setPostfix(t.image);
+ t = null;
+ afterNewline = false;
+ } else {
+ ;
+ }
+ end = jj_consume_token(END);
+ afterNewline = false;
+ if (jj_2_11(2) && (newlineAtStart || rsvc.getSpaceGobbling() == SpaceGobbling.BC)) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ break;
+ default:
+ jj_la1[29] = jj_gen;
+ ;
+ }
+ u = jj_consume_token(NEWLINE);
+ jjtn000.setPostfix(t == null ? u.image : t.image + u.image);
+ t = u = null;
+ afterNewline = true;
+ } else {
+ ;
+ }
+ int pos = end.image.lastIndexOf(hash);
+ if (pos > 0)
+ {
+ block.setMorePostfix(end.image.substring(0, pos));
+ }
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ /*
+ * VM : if we are processing a #macro directive, we need to
+ * process the block. In truth, I can just register the name
+ * and do the work later when init-ing. That would work
+ * as long as things were always defined before use. This way
+ * we don't have to worry about forward references and such...
+ */
+ if (isMacro)
+ {
+ // Add the macro name so that we can peform escape processing
+ // on defined macros
+ String macroName = jjtn000.jjtGetChild(0).getFirstToken().image;
+ macroNames.put(macroName, macroName);
+ }
+ if (d != null)
+ {
+ d.checkArgs(argtypes, id, currentTemplate.getName());
+ }
+ /*
+ * VM : end
+ */
+ {if (true) return afterNewline;}
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+/**
+ * for creating a map in a #set
+ *
+ * #set($foo = {$foo : $bar, $blargh : $thingy})
+ */
+ final public void Map() throws ParseException {
+ /*@bgen(jjtree) Map */
+ ASTMap jjtn000 = new ASTMap(this, JJTMAP);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(LEFT_CURLEY);
+ if (jj_2_12(2147483647)) {
+ Parameter();
+ jj_consume_token(COLON);
+ Parameter();
+ label_12:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case COMMA:
+ ;
+ break;
+ default:
+ jj_la1[30] = jj_gen;
+ break label_12;
+ }
+ jj_consume_token(COMMA);
+ Parameter();
+ jj_consume_token(COLON);
+ Parameter();
+ }
+ } else {
+ label_13:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[31] = jj_gen;
+ break label_13;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[32] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case RIGHT_CURLEY:
+ jj_consume_token(RIGHT_CURLEY);
+ break;
+ case RCURLY:
+ jj_consume_token(RCURLY);
+ break;
+ default:
+ jj_la1[33] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public void ObjectArray() throws ParseException {
+ /*@bgen(jjtree) ObjectArray */
+ ASTObjectArray jjtn000 = new ASTObjectArray(this, JJTOBJECTARRAY);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(LBRACKET);
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LBRACKET:
+ case LEFT_CURLEY:
+ case WHITESPACE:
+ case NEWLINE:
+ case STRING_LITERAL:
+ case TRUE:
+ case FALSE:
+ case INTEGER_LITERAL:
+ case FLOATING_POINT_LITERAL:
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ case LCURLY:
+ Parameter();
+ label_14:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case COMMA:
+ ;
+ break;
+ default:
+ jj_la1[34] = jj_gen;
+ break label_14;
+ }
+ jj_consume_token(COMMA);
+ Parameter();
+ }
+ break;
+ default:
+ jj_la1[35] = jj_gen;
+ ;
+ }
+ jj_consume_token(RBRACKET);
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+/**
+ * supports the [n..m] vector generator for use in
+ * the #foreach() to generate measured ranges w/o
+ * needing explicit support from the app/servlet
+ */
+ final public void IntegerRange() throws ParseException {
+ /*@bgen(jjtree) IntegerRange */
+ ASTIntegerRange jjtn000 = new ASTIntegerRange(this, JJTINTEGERRANGE);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(LBRACKET);
+ label_15:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[36] = jj_gen;
+ break label_15;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[37] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ case LCURLY:
+ Reference();
+ break;
+ case INTEGER_LITERAL:
+ IntegerLiteral();
+ break;
+ default:
+ jj_la1[38] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ label_16:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[39] = jj_gen;
+ break label_16;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[40] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ jj_consume_token(DOUBLEDOT);
+ label_17:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[41] = jj_gen;
+ break label_17;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[42] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ case LCURLY:
+ Reference();
+ break;
+ case INTEGER_LITERAL:
+ IntegerLiteral();
+ break;
+ default:
+ jj_la1[43] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ label_18:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[44] = jj_gen;
+ break label_18;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[45] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ jj_consume_token(RBRACKET);
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+/**
+ * A Simplified parameter more suitable for an index position: $foo[$index]
+ */
+ final public void IndexParameter() throws ParseException {
+ label_19:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[46] = jj_gen;
+ break label_19;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[47] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ Expression();
+ label_20:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[48] = jj_gen;
+ break label_20;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[49] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+
+/**
+ * This method has yet to be fully implemented
+ * but will allow arbitrarily nested method
+ * calls
+ */
+ final public void Parameter() throws ParseException {
+ label_21:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[50] = jj_gen;
+ break label_21;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[51] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case STRING_LITERAL:
+ StringLiteral();
+ break;
+ case INTEGER_LITERAL:
+ IntegerLiteral();
+ break;
+ default:
+ jj_la1[52] = jj_gen;
+ if (jj_2_13(2147483647)) {
+ IntegerRange();
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LEFT_CURLEY:
+ Map();
+ break;
+ case LBRACKET:
+ ObjectArray();
+ break;
+ case TRUE:
+ True();
+ break;
+ case FALSE:
+ False();
+ break;
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ case LCURLY:
+ Reference();
+ break;
+ case FLOATING_POINT_LITERAL:
+ FloatingPointLiteral();
+ break;
+ default:
+ jj_la1[53] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+ label_22:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[54] = jj_gen;
+ break label_22;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[55] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+
+/**
+ * This method has yet to be fully implemented
+ * but will allow arbitrarily nested method
+ * calls
+ */
+ final public void Method() throws ParseException {
+ /*@bgen(jjtree) Method */
+ ASTMethod jjtn000 = new ASTMethod(this, JJTMETHOD);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ Identifier();
+ jj_consume_token(LPAREN);
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LBRACKET:
+ case LEFT_CURLEY:
+ case LPAREN:
+ case WHITESPACE:
+ case NEWLINE:
+ case STRING_LITERAL:
+ case TRUE:
+ case FALSE:
+ case MINUS:
+ case LOGICAL_NOT:
+ case INTEGER_LITERAL:
+ case FLOATING_POINT_LITERAL:
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ case LCURLY:
+ Expression();
+ label_23:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case COMMA:
+ ;
+ break;
+ default:
+ jj_la1[56] = jj_gen;
+ break label_23;
+ }
+ jj_consume_token(COMMA);
+ Expression();
+ }
+ break;
+ default:
+ jj_la1[57] = jj_gen;
+ ;
+ }
+ jj_consume_token(REFMOD2_RPAREN);
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public void Index() throws ParseException {
+ /*@bgen(jjtree) Index */
+ ASTIndex jjtn000 = new ASTIndex(this, JJTINDEX);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(INDEX_LBRACKET);
+ IndexParameter();
+ jj_consume_token(INDEX_RBRACKET);
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public void Reference() throws ParseException {
+ /*@bgen(jjtree) Reference */
+ ASTReference jjtn000 = new ASTReference(this, JJTREFERENCE);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ jj_consume_token(IDENTIFIER);
+ break;
+ case OLD_IDENTIFIER:
+ jj_consume_token(OLD_IDENTIFIER);
+ break;
+ default:
+ jj_la1[58] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ label_24:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case INDEX_LBRACKET:
+ ;
+ break;
+ default:
+ jj_la1[59] = jj_gen;
+ break label_24;
+ }
+ Index();
+ }
+ label_25:
+ while (true) {
+ if (jj_2_14(2)) {
+ ;
+ } else {
+ break label_25;
+ }
+ jj_consume_token(DOT);
+ if (jj_2_15(3)) {
+ Method();
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ Identifier();
+ break;
+ default:
+ jj_la1[60] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ label_26:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case INDEX_LBRACKET:
+ ;
+ break;
+ default:
+ jj_la1[61] = jj_gen;
+ break label_26;
+ }
+ Index();
+ }
+ }
+ break;
+ case LCURLY:
+ jj_consume_token(LCURLY);
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ jj_consume_token(IDENTIFIER);
+ break;
+ case OLD_IDENTIFIER:
+ jj_consume_token(OLD_IDENTIFIER);
+ break;
+ default:
+ jj_la1[62] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ label_27:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case INDEX_LBRACKET:
+ ;
+ break;
+ default:
+ jj_la1[63] = jj_gen;
+ break label_27;
+ }
+ Index();
+ }
+ label_28:
+ while (true) {
+ if (jj_2_16(2)) {
+ ;
+ } else {
+ break label_28;
+ }
+ jj_consume_token(DOT);
+ if (jj_2_17(3)) {
+ Method();
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ Identifier();
+ break;
+ default:
+ jj_la1[64] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ label_29:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case INDEX_LBRACKET:
+ ;
+ break;
+ default:
+ jj_la1[65] = jj_gen;
+ break label_29;
+ }
+ Index();
+ }
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case PIPE:
+ jj_consume_token(PIPE);
+ Expression();
+ break;
+ default:
+ jj_la1[66] = jj_gen;
+ ;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case RCURLY:
+ jj_consume_token(RCURLY);
+ break;
+ case RIGHT_CURLEY:
+ jj_consume_token(RIGHT_CURLEY);
+ break;
+ default:
+ jj_la1[67] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ break;
+ default:
+ jj_la1[68] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public void True() throws ParseException {
+ /*@bgen(jjtree) True */
+ ASTTrue jjtn000 = new ASTTrue(this, JJTTRUE);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(TRUE);
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public void False() throws ParseException {
+ /*@bgen(jjtree) False */
+ ASTFalse jjtn000 = new ASTFalse(this, JJTFALSE);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ jj_consume_token(FALSE);
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+/**
+ * This method is responsible for allowing
+ * all non-grammar text to pass through
+ * unscathed.
+ * @return true if last read token was a newline
+ */
+ final public boolean Text() throws ParseException {
+ /*@bgen(jjtree) Text */
+ ASTText jjtn000 = new ASTText(this, JJTTEXT);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);Token t = null;
+ try {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case TEXT:
+ jj_consume_token(TEXT);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return true;}
+ break;
+ case DOT:
+ jj_consume_token(DOT);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case RPAREN:
+ jj_consume_token(RPAREN);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case LPAREN:
+ jj_consume_token(LPAREN);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case INTEGER_LITERAL:
+ jj_consume_token(INTEGER_LITERAL);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case FLOATING_POINT_LITERAL:
+ jj_consume_token(FLOATING_POINT_LITERAL);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case STRING_LITERAL:
+ jj_consume_token(STRING_LITERAL);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case ESCAPE:
+ jj_consume_token(ESCAPE);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case LCURLY:
+ jj_consume_token(LCURLY);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case RCURLY:
+ jj_consume_token(RCURLY);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case EMPTY_INDEX:
+ jj_consume_token(EMPTY_INDEX);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case PIPE:
+ jj_consume_token(PIPE);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return false;}
+ break;
+ case LONE_SYMBOL:
+ t = jj_consume_token(LONE_SYMBOL);
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ /* Drop the ending zero-width whitespace */
+ t.image = t.image.substring(0, t.image.length() - 1); {if (true) return false;}
+ break;
+ default:
+ jj_la1[69] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+/* -----------------------------------------------------------------------
+ *
+ * Defined Directive Syntax
+ *
+ * ----------------------------------------------------------------------*/
+ final public boolean IfStatement(boolean afterNewline) throws ParseException {
+ /*@bgen(jjtree) IfStatement */
+ ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);Token t = null, u = null, end = null;
+ ASTBlock lastBlock = null;
+ boolean newlineAtStart = afterNewline;
+ try {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ // only possible if not after new line
+ jjtn000.setPrefix(t.image);
+ t = null;
+ break;
+ default:
+ jj_la1[70] = jj_gen;
+ ;
+ }
+ jj_consume_token(IF_DIRECTIVE);
+ label_30:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[71] = jj_gen;
+ break label_30;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[72] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ jj_consume_token(LPAREN);
+ Expression();
+ jj_consume_token(RPAREN);
+ ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ if (jj_2_18(2)) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ break;
+ default:
+ jj_la1[73] = jj_gen;
+ ;
+ }
+ u = jj_consume_token(NEWLINE);
+ jjtn001.setPrefix(t == null ? u.image : t.image + u.image);
+ t = u = null;
+ afterNewline = true;
+ } else {
+ ;
+ }
+ label_31:
+ while (true) {
+ if ((getToken(1).kind != ELSEIF && getToken(1).kind != ELSE && getToken(1).kind != END) &&
+ (!afterNewline || getToken(1).kind != WHITESPACE || (getToken(2).kind != ELSEIF && getToken(2).kind != ELSE && getToken(2).kind != END))) {
+ ;
+ } else {
+ break label_31;
+ }
+ afterNewline = Statement(afterNewline);
+ }
+ jjtree.closeNodeScope(jjtn001, true);
+ jjtc001 = false;
+ lastBlock = jjtn001;
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, true);
+ }
+ }
+ if (getToken(1).kind == ELSEIF || (afterNewline && getToken(1).kind == WHITESPACE && getToken(2).kind == ELSEIF)) {
+ label_32:
+ while (true) {
+ lastBlock = ElseIfStatement(lastBlock, afterNewline);
+ afterNewline = lastBlock.endsWithNewline;
+ if (getToken(1).kind == ELSEIF || (afterNewline && getToken(1).kind == WHITESPACE && getToken(2).kind == ELSEIF)) {
+ ;
+ } else {
+ break label_32;
+ }
+ }
+ } else {
+ ;
+ }
+ if (getToken(1).kind == ELSE || (afterNewline && getToken(1).kind == WHITESPACE && getToken(2).kind == ELSE)) {
+ lastBlock = ElseStatement(lastBlock, afterNewline);
+ afterNewline = lastBlock.endsWithNewline;
+ } else {
+ ;
+ }
+ if (jj_2_19(1) && (afterNewline)) {
+ t = jj_consume_token(WHITESPACE);
+ lastBlock.setPostfix(t.image);
+ t = null;
+ } else {
+ ;
+ }
+ end = jj_consume_token(END);
+ afterNewline = false;
+ if (jj_2_20(2) && (newlineAtStart || rsvc.getSpaceGobbling() == SpaceGobbling.BC)) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ break;
+ default:
+ jj_la1[74] = jj_gen;
+ ;
+ }
+ u = jj_consume_token(NEWLINE);
+ jjtn000.setPostfix(t == null ? u.image : t.image + u.image);
+ afterNewline = true;
+ } else {
+ ;
+ }
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ int pos = end.image.lastIndexOf(hash);
+ if (pos > 0)
+ {
+ lastBlock.setMorePostfix(end.image.substring(0, pos));
+ }
+ {if (true) return afterNewline;}
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public ASTBlock ElseStatement(ASTBlock previousBlock, boolean afterNewline) throws ParseException {
+ /*@bgen(jjtree) ElseStatement */
+ ASTElseStatement jjtn000 = new ASTElseStatement(this, JJTELSESTATEMENT);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);Token t = null, u = null, _else = null;
+ ASTBlock block = null;
+ try {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ previousBlock.setPostfix(t.image);
+ t = null;
+ break;
+ default:
+ jj_la1[75] = jj_gen;
+ ;
+ }
+ _else = jj_consume_token(ELSE);
+ ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ if (jj_2_21(2)) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ break;
+ default:
+ jj_la1[76] = jj_gen;
+ ;
+ }
+ u = jj_consume_token(NEWLINE);
+ jjtn001.setPrefix(t == null ? u.image : t.image + u.image);
+ t = u = null;
+ afterNewline = true;
+ } else {
+ ;
+ }
+ label_33:
+ while (true) {
+ if (getToken(1).kind != END && (!afterNewline || getToken(1).kind != WHITESPACE || getToken(2).kind != END)) {
+ ;
+ } else {
+ break label_33;
+ }
+ afterNewline = Statement(afterNewline);
+ }
+ jjtree.closeNodeScope(jjtn001, true);
+ jjtc001 = false;
+ block = jjtn001;
+ block.endsWithNewline = afterNewline;
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, true);
+ }
+ }
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ int pos = _else.image.lastIndexOf(hash);
+ if (pos > 0)
+ {
+ previousBlock.setMorePostfix(_else.image.substring(0, pos));
+ }
+ {if (true) return block;}
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+ final public ASTBlock ElseIfStatement(ASTBlock previousBlock, boolean afterNewline) throws ParseException {
+ /*@bgen(jjtree) ElseIfStatement */
+ ASTElseIfStatement jjtn000 = new ASTElseIfStatement(this, JJTELSEIFSTATEMENT);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);Token t = null, u = null, elseif = null;
+ ASTBlock block = null;
+ try {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ previousBlock.setPostfix(t.image);
+ t = null;
+ break;
+ default:
+ jj_la1[77] = jj_gen;
+ ;
+ }
+ elseif = jj_consume_token(ELSEIF);
+ label_34:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[78] = jj_gen;
+ break label_34;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[79] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ jj_consume_token(LPAREN);
+ Expression();
+ jj_consume_token(RPAREN);
+ ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ if (jj_2_22(2)) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ break;
+ default:
+ jj_la1[80] = jj_gen;
+ ;
+ }
+ u = jj_consume_token(NEWLINE);
+ jjtn001.setPrefix(t == null ? u.image : t.image + u.image);
+ t = u = null;
+ afterNewline = true;
+ } else {
+ ;
+ }
+ label_35:
+ while (true) {
+ if ((getToken(1).kind != ELSEIF && getToken(1).kind != ELSE && getToken(1).kind != END) && (!afterNewline || getToken(1).kind != WHITESPACE || (getToken(2).kind != ELSEIF && getToken(2).kind != ELSE && getToken(2).kind != END))) {
+ ;
+ } else {
+ break label_35;
+ }
+ afterNewline = Statement(afterNewline);
+ }
+ jjtree.closeNodeScope(jjtn001, true);
+ jjtc001 = false;
+ block = jjtn001;
+ block.endsWithNewline = afterNewline;
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, true);
+ }
+ }
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ int pos = elseif.image.lastIndexOf(hash);
+ if (pos > 0)
+ {
+ previousBlock.setMorePostfix(elseif.image.substring(0, pos));
+ }
+ {if (true) return block;}
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+/**
+ * Currently support both types of set :
+ * #set( expr )
+ * #set expr
+ */
+ final public boolean SetDirective(boolean afterNewline) throws ParseException {
+ /*@bgen(jjtree) SetDirective */
+ ASTSetDirective jjtn000 = new ASTSetDirective(this, JJTSETDIRECTIVE);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);Token t = null, u = null;
+ boolean endsWithNewline = false;
+ try {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ // only possible after new line
+ jjtn000.setPrefix(t.image);
+ t = null;
+ break;
+ default:
+ jj_la1[81] = jj_gen;
+ ;
+ }
+ jj_consume_token(SET_DIRECTIVE);
+ label_36:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[82] = jj_gen;
+ break label_36;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[83] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ Reference();
+ label_37:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[84] = jj_gen;
+ break label_37;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[85] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ jj_consume_token(EQUALS);
+ Expression();
+ jj_consume_token(RPAREN);
+ /*
+ * ensure that inSet is false. Leads to some amusing bugs...
+ */
+
+ token_source.setInSet(false);
+ if (jj_2_23(2) && (afterNewline || rsvc.getSpaceGobbling() == SpaceGobbling.BC)) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ t = jj_consume_token(WHITESPACE);
+ break;
+ default:
+ jj_la1[86] = jj_gen;
+ ;
+ }
+ u = jj_consume_token(NEWLINE);
+ jjtn000.setPostfix(t == null ? u.image : t.image + u.image);
+ endsWithNewline = true;
+ } else {
+ ;
+ }
+ jjtree.closeNodeScope(jjtn000, true);
+ jjtc000 = false;
+ {if (true) return endsWithNewline;}
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ throw new Error("Missing return statement in function");
+ }
+
+/* -----------------------------------------------------------------------
+ *
+ * Expression Syntax
+ *
+ * ----------------------------------------------------------------------*/
+ final public void Expression() throws ParseException {
+ /*@bgen(jjtree) Expression */
+ ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ ConditionalOrExpression();
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, true);
+ }
+ }
+ }
+
+ final public void Assignment() throws ParseException {
+ /*@bgen(jjtree) #Assignment( 2) */
+ ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
+ boolean jjtc000 = true;
+ jjtree.openNodeScope(jjtn000);
+ try {
+ PrimaryExpression();
+ jj_consume_token(EQUALS);
+ Expression();
+ } catch (Throwable jjte000) {
+ if (jjtc000) {
+ jjtree.clearNodeScope(jjtn000);
+ jjtc000 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte000 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte000;}
+ }
+ if (jjte000 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte000;}
+ }
+ {if (true) throw (Error)jjte000;}
+ } finally {
+ if (jjtc000) {
+ jjtree.closeNodeScope(jjtn000, 2);
+ }
+ }
+ }
+
+ final public void ConditionalOrExpression() throws ParseException {
+ ConditionalAndExpression();
+ label_38:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LOGICAL_OR_2:
+ case LOGICAL_OR:
+ ;
+ break;
+ default:
+ jj_la1[87] = jj_gen;
+ break label_38;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LOGICAL_OR:
+ jj_consume_token(LOGICAL_OR);
+ break;
+ case LOGICAL_OR_2:
+ jj_consume_token(LOGICAL_OR_2);
+ break;
+ default:
+ jj_la1[88] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ ASTOrNode jjtn001 = new ASTOrNode(this, JJTORNODE);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ ConditionalAndExpression();
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, 2);
+ }
+ }
+ }
+ }
+
+ final public void ConditionalAndExpression() throws ParseException {
+ EqualityExpression();
+ label_39:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LOGICAL_AND:
+ ;
+ break;
+ default:
+ jj_la1[89] = jj_gen;
+ break label_39;
+ }
+ jj_consume_token(LOGICAL_AND);
+ ASTAndNode jjtn001 = new ASTAndNode(this, JJTANDNODE);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ EqualityExpression();
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, 2);
+ }
+ }
+ }
+ }
+
+ final public void EqualityExpression() throws ParseException {
+ RelationalExpression();
+ label_40:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LOGICAL_EQUALS:
+ case LOGICAL_NOT_EQUALS:
+ ;
+ break;
+ default:
+ jj_la1[90] = jj_gen;
+ break label_40;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LOGICAL_EQUALS:
+ jj_consume_token(LOGICAL_EQUALS);
+ ASTEQNode jjtn001 = new ASTEQNode(this, JJTEQNODE);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ RelationalExpression();
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, 2);
+ }
+ }
+ break;
+ case LOGICAL_NOT_EQUALS:
+ jj_consume_token(LOGICAL_NOT_EQUALS);
+ ASTNENode jjtn002 = new ASTNENode(this, JJTNENODE);
+ boolean jjtc002 = true;
+ jjtree.openNodeScope(jjtn002);
+ try {
+ RelationalExpression();
+ } catch (Throwable jjte002) {
+ if (jjtc002) {
+ jjtree.clearNodeScope(jjtn002);
+ jjtc002 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte002 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte002;}
+ }
+ if (jjte002 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte002;}
+ }
+ {if (true) throw (Error)jjte002;}
+ } finally {
+ if (jjtc002) {
+ jjtree.closeNodeScope(jjtn002, 2);
+ }
+ }
+ break;
+ default:
+ jj_la1[91] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+
+ final public void RelationalExpression() throws ParseException {
+ AdditiveExpression();
+ label_41:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LOGICAL_LT:
+ case LOGICAL_LE:
+ case LOGICAL_GT:
+ case LOGICAL_GE:
+ ;
+ break;
+ default:
+ jj_la1[92] = jj_gen;
+ break label_41;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LOGICAL_LT:
+ jj_consume_token(LOGICAL_LT);
+ ASTLTNode jjtn001 = new ASTLTNode(this, JJTLTNODE);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ AdditiveExpression();
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, 2);
+ }
+ }
+ break;
+ case LOGICAL_GT:
+ jj_consume_token(LOGICAL_GT);
+ ASTGTNode jjtn002 = new ASTGTNode(this, JJTGTNODE);
+ boolean jjtc002 = true;
+ jjtree.openNodeScope(jjtn002);
+ try {
+ AdditiveExpression();
+ } catch (Throwable jjte002) {
+ if (jjtc002) {
+ jjtree.clearNodeScope(jjtn002);
+ jjtc002 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte002 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte002;}
+ }
+ if (jjte002 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte002;}
+ }
+ {if (true) throw (Error)jjte002;}
+ } finally {
+ if (jjtc002) {
+ jjtree.closeNodeScope(jjtn002, 2);
+ }
+ }
+ break;
+ case LOGICAL_LE:
+ jj_consume_token(LOGICAL_LE);
+ ASTLENode jjtn003 = new ASTLENode(this, JJTLENODE);
+ boolean jjtc003 = true;
+ jjtree.openNodeScope(jjtn003);
+ try {
+ AdditiveExpression();
+ } catch (Throwable jjte003) {
+ if (jjtc003) {
+ jjtree.clearNodeScope(jjtn003);
+ jjtc003 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte003 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte003;}
+ }
+ if (jjte003 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte003;}
+ }
+ {if (true) throw (Error)jjte003;}
+ } finally {
+ if (jjtc003) {
+ jjtree.closeNodeScope(jjtn003, 2);
+ }
+ }
+ break;
+ case LOGICAL_GE:
+ jj_consume_token(LOGICAL_GE);
+ ASTGENode jjtn004 = new ASTGENode(this, JJTGENODE);
+ boolean jjtc004 = true;
+ jjtree.openNodeScope(jjtn004);
+ try {
+ AdditiveExpression();
+ } catch (Throwable jjte004) {
+ if (jjtc004) {
+ jjtree.clearNodeScope(jjtn004);
+ jjtc004 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte004 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte004;}
+ }
+ if (jjte004 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte004;}
+ }
+ {if (true) throw (Error)jjte004;}
+ } finally {
+ if (jjtc004) {
+ jjtree.closeNodeScope(jjtn004, 2);
+ }
+ }
+ break;
+ default:
+ jj_la1[93] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+
+ final public void AdditiveExpression() throws ParseException {
+ MultiplicativeExpression();
+ label_42:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case MINUS:
+ case PLUS:
+ ;
+ break;
+ default:
+ jj_la1[94] = jj_gen;
+ break label_42;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case PLUS:
+ jj_consume_token(PLUS);
+ ASTAddNode jjtn001 = new ASTAddNode(this, JJTADDNODE);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ MultiplicativeExpression();
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, 2);
+ }
+ }
+ break;
+ case MINUS:
+ jj_consume_token(MINUS);
+ ASTSubtractNode jjtn002 = new ASTSubtractNode(this, JJTSUBTRACTNODE);
+ boolean jjtc002 = true;
+ jjtree.openNodeScope(jjtn002);
+ try {
+ MultiplicativeExpression();
+ } catch (Throwable jjte002) {
+ if (jjtc002) {
+ jjtree.clearNodeScope(jjtn002);
+ jjtc002 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte002 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte002;}
+ }
+ if (jjte002 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte002;}
+ }
+ {if (true) throw (Error)jjte002;}
+ } finally {
+ if (jjtc002) {
+ jjtree.closeNodeScope(jjtn002, 2);
+ }
+ }
+ break;
+ default:
+ jj_la1[95] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+
+ final public void MultiplicativeExpression() throws ParseException {
+ UnaryExpression();
+ label_43:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case MULTIPLY:
+ case DIVIDE:
+ case MODULUS:
+ ;
+ break;
+ default:
+ jj_la1[96] = jj_gen;
+ break label_43;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case MULTIPLY:
+ jj_consume_token(MULTIPLY);
+ ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ UnaryExpression();
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, 2);
+ }
+ }
+ break;
+ case DIVIDE:
+ jj_consume_token(DIVIDE);
+ ASTDivNode jjtn002 = new ASTDivNode(this, JJTDIVNODE);
+ boolean jjtc002 = true;
+ jjtree.openNodeScope(jjtn002);
+ try {
+ UnaryExpression();
+ } catch (Throwable jjte002) {
+ if (jjtc002) {
+ jjtree.clearNodeScope(jjtn002);
+ jjtc002 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte002 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte002;}
+ }
+ if (jjte002 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte002;}
+ }
+ {if (true) throw (Error)jjte002;}
+ } finally {
+ if (jjtc002) {
+ jjtree.closeNodeScope(jjtn002, 2);
+ }
+ }
+ break;
+ case MODULUS:
+ jj_consume_token(MODULUS);
+ ASTModNode jjtn003 = new ASTModNode(this, JJTMODNODE);
+ boolean jjtc003 = true;
+ jjtree.openNodeScope(jjtn003);
+ try {
+ UnaryExpression();
+ } catch (Throwable jjte003) {
+ if (jjtc003) {
+ jjtree.clearNodeScope(jjtn003);
+ jjtc003 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte003 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte003;}
+ }
+ if (jjte003 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte003;}
+ }
+ {if (true) throw (Error)jjte003;}
+ } finally {
+ if (jjtc003) {
+ jjtree.closeNodeScope(jjtn003, 2);
+ }
+ }
+ break;
+ default:
+ jj_la1[97] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+
+ final public void UnaryExpression() throws ParseException {
+ label_44:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[98] = jj_gen;
+ break label_44;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[99] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case LOGICAL_NOT:
+ jj_consume_token(LOGICAL_NOT);
+ ASTNotNode jjtn001 = new ASTNotNode(this, JJTNOTNODE);
+ boolean jjtc001 = true;
+ jjtree.openNodeScope(jjtn001);
+ try {
+ UnaryExpression();
+ } catch (Throwable jjte001) {
+ if (jjtc001) {
+ jjtree.clearNodeScope(jjtn001);
+ jjtc001 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte001 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte001;}
+ }
+ if (jjte001 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte001;}
+ }
+ {if (true) throw (Error)jjte001;}
+ } finally {
+ if (jjtc001) {
+ jjtree.closeNodeScope(jjtn001, 1);
+ }
+ }
+ break;
+ case MINUS:
+ jj_consume_token(MINUS);
+ ASTNegateNode jjtn002 = new ASTNegateNode(this, JJTNEGATENODE);
+ boolean jjtc002 = true;
+ jjtree.openNodeScope(jjtn002);
+ try {
+ PrimaryExpression();
+ } catch (Throwable jjte002) {
+ if (jjtc002) {
+ jjtree.clearNodeScope(jjtn002);
+ jjtc002 = false;
+ } else {
+ jjtree.popNode();
+ }
+ if (jjte002 instanceof RuntimeException) {
+ {if (true) throw (RuntimeException)jjte002;}
+ }
+ if (jjte002 instanceof ParseException) {
+ {if (true) throw (ParseException)jjte002;}
+ }
+ {if (true) throw (Error)jjte002;}
+ } finally {
+ if (jjtc002) {
+ jjtree.closeNodeScope(jjtn002, 1);
+ }
+ }
+ break;
+ case LBRACKET:
+ case LEFT_CURLEY:
+ case LPAREN:
+ case WHITESPACE:
+ case NEWLINE:
+ case STRING_LITERAL:
+ case TRUE:
+ case FALSE:
+ case INTEGER_LITERAL:
+ case FLOATING_POINT_LITERAL:
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ case LCURLY:
+ PrimaryExpression();
+ break;
+ default:
+ jj_la1[100] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+
+ final public void PrimaryExpression() throws ParseException {
+ label_45:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[101] = jj_gen;
+ break label_45;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[102] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case STRING_LITERAL:
+ StringLiteral();
+ break;
+ case IDENTIFIER:
+ case OLD_IDENTIFIER:
+ case LCURLY:
+ Reference();
+ break;
+ case INTEGER_LITERAL:
+ IntegerLiteral();
+ break;
+ default:
+ jj_la1[103] = jj_gen;
+ if (jj_2_24(2147483647)) {
+ IntegerRange();
+ } else {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case FLOATING_POINT_LITERAL:
+ FloatingPointLiteral();
+ break;
+ case LEFT_CURLEY:
+ Map();
+ break;
+ case LBRACKET:
+ ObjectArray();
+ break;
+ case TRUE:
+ True();
+ break;
+ case FALSE:
+ False();
+ break;
+ case LPAREN:
+ jj_consume_token(LPAREN);
+ Expression();
+ jj_consume_token(RPAREN);
+ break;
+ default:
+ jj_la1[104] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+ label_46:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ case NEWLINE:
+ ;
+ break;
+ default:
+ jj_la1[105] = jj_gen;
+ break label_46;
+ }
+ switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+ case WHITESPACE:
+ jj_consume_token(WHITESPACE);
+ break;
+ case NEWLINE:
+ jj_consume_token(NEWLINE);
+ break;
+ default:
+ jj_la1[106] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+
+ 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_3_20() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) jj_scanpos = xsp;
+ if (jj_scan_token(NEWLINE)) return true;
+ return false;
+ }
+
+ private boolean jj_3_19() {
+ if (jj_scan_token(WHITESPACE)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_55() {
+ return false;
+ }
+
+ private boolean jj_3R_54() {
+ if (jj_3R_76()) return true;
+ return false;
+ }
+
+ private boolean jj_3_6() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_54()) jj_scanpos = xsp;
+ jj_lookingAhead = true;
+ jj_semLA = !isRightParenthesis();
+ jj_lookingAhead = false;
+ if (!jj_semLA || jj_3R_55()) return true;
+ if (jj_3R_56()) return true;
+ return false;
+ }
+
+ private boolean jj_3_18() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) jj_scanpos = xsp;
+ if (jj_scan_token(NEWLINE)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_126() {
+ if (jj_3R_110()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_62() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_125() {
+ if (jj_3R_110()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_65() {
+ if (jj_3R_98()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_69() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_63() {
+ if (jj_3R_98()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_111() {
+ if (jj_3R_110()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_53() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_61() {
+ if (jj_3R_75()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_100() {
+ if (jj_3R_110()) return true;
+ return false;
+ }
+
+ private boolean jj_3_17() {
+ if (jj_3R_64()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_68() {
+ if (jj_3R_75()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_60() {
+ if (jj_3R_47()) return true;
+ return false;
+ }
+
+ private boolean jj_3_15() {
+ if (jj_3R_64()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_137() {
+ if (jj_scan_token(COMMA)) return true;
+ if (jj_3R_109()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_52() {
+ if (jj_3R_75()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_108() {
+ if (jj_scan_token(FALSE)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_67() {
+ if (jj_3R_47()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_107() {
+ if (jj_scan_token(TRUE)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_112() {
+ if (jj_scan_token(PIPE)) return true;
+ if (jj_3R_109()) return true;
+ return false;
+ }
+
+ private boolean jj_3_16() {
+ if (jj_scan_token(DOT)) return true;
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3_17()) {
+ jj_scanpos = xsp;
+ if (jj_3R_65()) return true;
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_126()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_127() {
+ if (jj_scan_token(COMMA)) return true;
+ if (jj_3R_58()) return true;
+ if (jj_scan_token(COLON)) return true;
+ if (jj_3R_58()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_51() {
+ if (jj_3R_47()) return true;
+ return false;
+ }
+
+ private boolean jj_3_14() {
+ if (jj_scan_token(DOT)) return true;
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3_15()) {
+ jj_scanpos = xsp;
+ if (jj_3R_63()) return true;
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_125()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_99() {
+ if (jj_3R_109()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_137()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_71() {
+ if (jj_scan_token(LCURLY)) return true;
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(67)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(70)) return true;
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_111()) { jj_scanpos = xsp; break; }
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3_16()) { jj_scanpos = xsp; break; }
+ }
+ xsp = jj_scanpos;
+ if (jj_3R_112()) jj_scanpos = xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(73)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(13)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_70() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(67)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(70)) return true;
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_100()) { jj_scanpos = xsp; break; }
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3_14()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_59() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_47() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_70()) {
+ jj_scanpos = xsp;
+ if (jj_3R_71()) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_110() {
+ if (jj_scan_token(INDEX_LBRACKET)) return true;
+ if (jj_3R_131()) return true;
+ if (jj_scan_token(INDEX_RBRACKET)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_66() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3_13() {
+ if (jj_scan_token(LBRACKET)) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_59()) { jj_scanpos = xsp; break; }
+ }
+ xsp = jj_scanpos;
+ if (jj_3R_60()) {
+ jj_scanpos = xsp;
+ if (jj_3R_61()) return true;
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_62()) { jj_scanpos = xsp; break; }
+ }
+ if (jj_scan_token(DOUBLEDOT)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_64() {
+ if (jj_3R_98()) return true;
+ if (jj_scan_token(LPAREN)) return true;
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_99()) jj_scanpos = xsp;
+ if (jj_scan_token(REFMOD2_RPAREN)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_76() {
+ if (jj_3R_47()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_50() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_96() {
+ if (jj_3R_104()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_95() {
+ if (jj_3R_47()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_94() {
+ if (jj_3R_108()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_93() {
+ if (jj_3R_107()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_97() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_117() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_86() {
+ if (jj_3R_108()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_92() {
+ if (jj_3R_106()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_91() {
+ if (jj_3R_105()) return true;
+ return false;
+ }
+
+ private boolean jj_3_24() {
+ if (jj_scan_token(LBRACKET)) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_66()) { jj_scanpos = xsp; break; }
+ }
+ xsp = jj_scanpos;
+ if (jj_3R_67()) {
+ jj_scanpos = xsp;
+ if (jj_3R_68()) return true;
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_69()) { jj_scanpos = xsp; break; }
+ }
+ if (jj_scan_token(DOUBLEDOT)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_90() {
+ if (jj_3R_103()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_89() {
+ if (jj_3R_75()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_85() {
+ if (jj_3R_107()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_173() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_88() {
+ if (jj_3R_102()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_172() {
+ if (jj_scan_token(LPAREN)) return true;
+ if (jj_3R_109()) return true;
+ if (jj_scan_token(RPAREN)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_171() {
+ if (jj_3R_108()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_84() {
+ if (jj_3R_106()) return true;
+ return false;
+ }
+
+ private boolean jj_3_5() {
+ if (jj_scan_token(LBRACKET)) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_50()) { jj_scanpos = xsp; break; }
+ }
+ xsp = jj_scanpos;
+ if (jj_3R_51()) {
+ jj_scanpos = xsp;
+ if (jj_3R_52()) return true;
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_53()) { jj_scanpos = xsp; break; }
+ }
+ if (jj_scan_token(DOUBLEDOT)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_170() {
+ if (jj_3R_107()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_169() {
+ if (jj_3R_106()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_168() {
+ if (jj_3R_105()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_87() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_167() {
+ if (jj_3R_104()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_83() {
+ if (jj_3R_105()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_58() {
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_87()) { jj_scanpos = xsp; break; }
+ }
+ xsp = jj_scanpos;
+ if (jj_3R_88()) {
+ jj_scanpos = xsp;
+ if (jj_3R_89()) {
+ jj_scanpos = xsp;
+ if (jj_3R_90()) {
+ jj_scanpos = xsp;
+ if (jj_3R_91()) {
+ jj_scanpos = xsp;
+ if (jj_3R_92()) {
+ jj_scanpos = xsp;
+ if (jj_3R_93()) {
+ jj_scanpos = xsp;
+ if (jj_3R_94()) {
+ jj_scanpos = xsp;
+ if (jj_3R_95()) {
+ jj_scanpos = xsp;
+ if (jj_3R_96()) return true;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_97()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_166() {
+ if (jj_3R_103()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_165() {
+ if (jj_3R_75()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_164() {
+ if (jj_3R_47()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_82() {
+ if (jj_3R_104()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_163() {
+ if (jj_3R_102()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_162() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_158() {
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_162()) { jj_scanpos = xsp; break; }
+ }
+ xsp = jj_scanpos;
+ if (jj_3R_163()) {
+ jj_scanpos = xsp;
+ if (jj_3R_164()) {
+ jj_scanpos = xsp;
+ if (jj_3R_165()) {
+ jj_scanpos = xsp;
+ if (jj_3R_166()) {
+ jj_scanpos = xsp;
+ if (jj_3R_167()) {
+ jj_scanpos = xsp;
+ if (jj_3R_168()) {
+ jj_scanpos = xsp;
+ if (jj_3R_169()) {
+ jj_scanpos = xsp;
+ if (jj_3R_170()) {
+ jj_scanpos = xsp;
+ if (jj_3R_171()) {
+ jj_scanpos = xsp;
+ if (jj_3R_172()) return true;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_173()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_154() {
+ if (jj_3R_158()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_81() {
+ if (jj_3R_103()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_153() {
+ if (jj_scan_token(MINUS)) return true;
+ if (jj_3R_158()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_152() {
+ if (jj_scan_token(LOGICAL_NOT)) return true;
+ if (jj_3R_145()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_119() {
+ if (jj_3R_75()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_134() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_115() {
+ if (jj_3R_75()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_129() {
+ if (jj_scan_token(COMMA)) return true;
+ if (jj_3R_58()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_133() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_80() {
+ if (jj_3R_75()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_131() {
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_133()) { jj_scanpos = xsp; break; }
+ }
+ if (jj_3R_109()) return true;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_134()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_161() {
+ if (jj_scan_token(MODULUS)) return true;
+ if (jj_3R_145()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_113() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_151() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_160() {
+ if (jj_scan_token(DIVIDE)) return true;
+ if (jj_3R_145()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_159() {
+ if (jj_scan_token(MULTIPLY)) return true;
+ if (jj_3R_145()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_155() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_159()) {
+ jj_scanpos = xsp;
+ if (jj_3R_160()) {
+ jj_scanpos = xsp;
+ if (jj_3R_161()) return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_145() {
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_151()) { jj_scanpos = xsp; break; }
+ }
+ xsp = jj_scanpos;
+ if (jj_3R_152()) {
+ jj_scanpos = xsp;
+ if (jj_3R_153()) {
+ jj_scanpos = xsp;
+ if (jj_3R_154()) return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_79() {
+ if (jj_3R_102()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_120() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_78() {
+ if (jj_3R_101()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_118() {
+ if (jj_3R_47()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_114() {
+ if (jj_3R_47()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_116() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_123() {
+ if (jj_3R_58()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_129()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_77() {
+ if (jj_3R_47()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_56() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_77()) {
+ jj_scanpos = xsp;
+ if (jj_3R_78()) {
+ jj_scanpos = xsp;
+ if (jj_3R_79()) {
+ jj_scanpos = xsp;
+ if (jj_3R_80()) {
+ jj_scanpos = xsp;
+ if (jj_3R_81()) {
+ jj_scanpos = xsp;
+ if (jj_3R_82()) {
+ jj_scanpos = xsp;
+ if (jj_3R_83()) {
+ jj_scanpos = xsp;
+ if (jj_3R_84()) {
+ jj_scanpos = xsp;
+ if (jj_3R_85()) {
+ jj_scanpos = xsp;
+ if (jj_3R_86()) return true;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_103() {
+ if (jj_scan_token(LBRACKET)) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_113()) { jj_scanpos = xsp; break; }
+ }
+ xsp = jj_scanpos;
+ if (jj_3R_114()) {
+ jj_scanpos = xsp;
+ if (jj_3R_115()) return true;
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_116()) { jj_scanpos = xsp; break; }
+ }
+ if (jj_scan_token(DOUBLEDOT)) return true;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_117()) { jj_scanpos = xsp; break; }
+ }
+ xsp = jj_scanpos;
+ if (jj_3R_118()) {
+ jj_scanpos = xsp;
+ if (jj_3R_119()) return true;
+ }
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_120()) { jj_scanpos = xsp; break; }
+ }
+ if (jj_scan_token(RBRACKET)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_141() {
+ if (jj_3R_145()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_155()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_157() {
+ if (jj_scan_token(MINUS)) return true;
+ if (jj_3R_141()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_156() {
+ if (jj_scan_token(PLUS)) return true;
+ if (jj_3R_141()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_146() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_156()) {
+ jj_scanpos = xsp;
+ if (jj_3R_157()) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_101() {
+ if (jj_scan_token(WORD)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_57() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_139() {
+ if (jj_3R_141()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_146()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3_12() {
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_57()) { jj_scanpos = xsp; break; }
+ }
+ if (jj_3R_58()) return true;
+ if (jj_scan_token(COLON)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_106() {
+ if (jj_scan_token(LBRACKET)) return true;
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_123()) jj_scanpos = xsp;
+ if (jj_scan_token(RBRACKET)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_150() {
+ if (jj_scan_token(LOGICAL_GE)) return true;
+ if (jj_3R_139()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_149() {
+ if (jj_scan_token(LOGICAL_LE)) return true;
+ if (jj_3R_139()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_98() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(67)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(70)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_148() {
+ if (jj_scan_token(LOGICAL_GT)) return true;
+ if (jj_3R_139()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_142() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_147()) {
+ jj_scanpos = xsp;
+ if (jj_3R_148()) {
+ jj_scanpos = xsp;
+ if (jj_3R_149()) {
+ jj_scanpos = xsp;
+ if (jj_3R_150()) return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_147() {
+ if (jj_scan_token(LOGICAL_LT)) return true;
+ if (jj_3R_139()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_128() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(33)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_122() {
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_128()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_121() {
+ if (jj_3R_58()) return true;
+ if (jj_scan_token(COLON)) return true;
+ if (jj_3R_58()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_127()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_136() {
+ if (jj_3R_139()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_142()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_144() {
+ if (jj_scan_token(LOGICAL_NOT_EQUALS)) return true;
+ if (jj_3R_136()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_105() {
+ if (jj_scan_token(LEFT_CURLEY)) return true;
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_121()) {
+ jj_scanpos = xsp;
+ if (jj_3R_122()) return true;
+ }
+ xsp = jj_scanpos;
+ if (jj_scan_token(13)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(73)) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_140() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_143()) {
+ jj_scanpos = xsp;
+ if (jj_3R_144()) return true;
+ }
+ return false;
+ }
+
+ private boolean jj_3R_143() {
+ if (jj_scan_token(LOGICAL_EQUALS)) return true;
+ if (jj_3R_136()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_102() {
+ if (jj_scan_token(STRING_LITERAL)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_132() {
+ if (jj_3R_136()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_140()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_75() {
+ if (jj_scan_token(INTEGER_LITERAL)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_138() {
+ if (jj_scan_token(LOGICAL_AND)) return true;
+ if (jj_3R_132()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_130() {
+ if (jj_3R_132()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_138()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_104() {
+ if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_135() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(44)) {
+ jj_scanpos = xsp;
+ if (jj_scan_token(4)) return true;
+ }
+ if (jj_3R_130()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_124() {
+ if (jj_3R_130()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_135()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_72() {
+ if (jj_scan_token(SINGLE_LINE_COMMENT_START)) return true;
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(26)) jj_scanpos = xsp;
+ return false;
+ }
+
+ private boolean jj_3R_48() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_72()) {
+ jj_scanpos = xsp;
+ if (jj_3R_73()) {
+ jj_scanpos = xsp;
+ if (jj_3R_74()) return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_74() {
+ if (jj_scan_token(FORMAL_COMMENT)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_73() {
+ if (jj_scan_token(MULTI_LINE_COMMENT)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_109() {
+ if (jj_3R_124()) return true;
+ return false;
+ }
+
+ private boolean jj_3_11() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) jj_scanpos = xsp;
+ if (jj_scan_token(NEWLINE)) return true;
+ return false;
+ }
+
+ private boolean jj_3_23() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) jj_scanpos = xsp;
+ if (jj_scan_token(NEWLINE)) return true;
+ return false;
+ }
+
+ private boolean jj_3_10() {
+ if (jj_scan_token(WHITESPACE)) return true;
+ return false;
+ }
+
+ private boolean jj_3_4() {
+ if (jj_scan_token(DOUBLE_ESCAPE)) return true;
+ return false;
+ }
+
+ private boolean jj_3_9() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) jj_scanpos = xsp;
+ if (jj_scan_token(NEWLINE)) return true;
+ return false;
+ }
+
+ private boolean jj_3_22() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) jj_scanpos = xsp;
+ if (jj_scan_token(NEWLINE)) return true;
+ return false;
+ }
+
+ private boolean jj_3_8() {
+ if (jj_scan_token(WHITESPACE)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_49() {
+ if (jj_scan_token(ZERO_WIDTH_WHITESPACE)) return true;
+ if (jj_scan_token(0)) return true;
+ return false;
+ }
+
+ private boolean jj_3_3() {
+ if (jj_3R_49()) return true;
+ return false;
+ }
+
+ private boolean jj_3_2() {
+ if (jj_3R_48()) return true;
+ return false;
+ }
+
+ private boolean jj_3_1() {
+ if (jj_3R_47()) return true;
+ return false;
+ }
+
+ private boolean jj_3_21() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) jj_scanpos = xsp;
+ if (jj_scan_token(NEWLINE)) return true;
+ return false;
+ }
+
+ private boolean jj_3_7() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_scan_token(32)) jj_scanpos = xsp;
+ if (jj_scan_token(NEWLINE)) return true;
+ return false;
+ }
+
+ /** Generated Token Manager. */
+ public StandardParserTokenManager token_source;
+ /** 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[107];
+ static private int[] jj_la1_0;
+ static private int[] jj_la1_1;
+ static private int[] jj_la1_2;
+ static {
+ jj_la1_init_0();
+ jj_la1_init_1();
+ jj_la1_init_2();
+ }
+ private static void jj_la1_init_0() {
+ jj_la1_0 = new int[] {0x0,0x20000000,0x20000,0xc022,0x14,0x4000000,0x1a000000,0x0,0x0,0x1080,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x4000000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x2000,0x200,0x1080,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1080,0x0,0x0,0x200,0x5080,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x20,0x2000,0x0,0xc022,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5080,0x0,0x0,0x0,0x5080,0x0,0x0,};
+ }
+ private static void jj_la1_init_1() {
+ jj_la1_1 = new int[] {0x0,0x0,0x0,0xc00000f,0x0,0x0,0x0,0x0,0x84000008,0x8000030,0x1,0x80000000,0x3,0x3,0x3,0x3,0x3,0x3,0x0,0x3,0x3,0x3,0x3,0x0,0x0,0x3,0x3,0x1,0x1,0x1,0x0,0x3,0x3,0x0,0x0,0xc00003b,0x3,0x3,0x4000000,0x3,0x3,0x3,0x3,0x4000000,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4000008,0x8000030,0x3,0x3,0x0,0xc08007b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000008,0x1,0x3,0x3,0x1,0x1,0x1,0x1,0x1,0x3,0x3,0x1,0x1,0x3,0x3,0x3,0x3,0x1,0x1000,0x1000,0x800,0x60000,0x60000,0x1e000,0x1e000,0xc0,0xc0,0x700,0x700,0x3,0x3,0xc08007b,0x3,0x3,0x4000008,0x8000030,0x3,0x3,};
+ }
+ private static void jj_la1_init_2() {
+ jj_la1_2 = new int[] {0x4000,0x0,0x1000,0x1e380,0x0,0x0,0x0,0x48,0x148,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x148,0x0,0x0,0x148,0x0,0x0,0x0,0x0,0x148,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x148,0x0,0x0,0x0,0x148,0x48,0x0,0x48,0x0,0x48,0x0,0x48,0x0,0x0,0x200,0x148,0x16380,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,0x148,0x0,0x0,0x148,0x0,0x0,0x0,};
+ }
+ final private JJCalls[] jj_2_rtns = new JJCalls[24];
+ private boolean jj_rescan = false;
+ private int jj_gc = 0;
+
+ /** Constructor with user supplied CharStream. */
+ public StandardParser(CharStream stream) {
+ token_source = new StandardParserTokenManager(this, stream);
+ token = new Token();
+ jj_ntk = -1;
+ jj_gen = 0;
+ for (int i = 0; i < 107; 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(CharStream stream) {
+ token_source.ReInit(stream);
+ token = new Token();
+ jj_ntk = -1;
+ jj_lookingAhead = false;
+ jjtree.reset();
+ jj_gen = 0;
+ for (int i = 0; i < 107; 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 StandardParser(StandardParserTokenManager tm) {
+ token_source = tm;
+ token = new Token();
+ jj_ntk = -1;
+ jj_gen = 0;
+ for (int i = 0; i < 107; 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(StandardParserTokenManager tm) {
+ token_source = tm;
+ token = new Token();
+ jj_ntk = -1;
+ jjtree.reset();
+ jj_gen = 0;
+ for (int i = 0; i < 107; 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();
+ }
+
+ static private final class LookaheadSuccess extends java.lang.Error { }
+ 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() {
+ 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];
+ }
+ jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
+ int[] oldentry = (int[])(it.next());
+ if (oldentry.length == jj_expentry.length) {
+ for (int i = 0; i < jj_expentry.length; i++) {
+ if (oldentry[i] != jj_expentry[i]) {
+ continue jj_entries_loop;
+ }
+ }
+ jj_expentries.add(jj_expentry);
+ break jj_entries_loop;
+ }
+ }
+ if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
+ }
+ }
+
+ /** Generate ParseException. */
+ public ParseException generateParseException() {
+ jj_expentries.clear();
+ boolean[] la1tokens = new boolean[81];
+ if (jj_kind >= 0) {
+ la1tokens[jj_kind] = true;
+ jj_kind = -1;
+ }
+ for (int i = 0; i < 107; 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;
+ }
+ }
+ }
+ }
+ for (int i = 0; i < 81; 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);
+ }
+
+ /** 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 < 24; 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;
+ }
+ }
+ 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/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserConstants.java b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserConstants.java
new file mode 100644
index 0000000..32e9771
--- /dev/null
+++ b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserConstants.java
@@ -0,0 +1,286 @@
+/* Generated By:JJTree&JavaCC: Do not edit this line. StandardParserConstants.java */
+package org.apache.velocity.runtime.parser;
+
+
+/**
+ * Token literal values and constants.
+ * Generated by org.javacc.parser.OtherFilesGen#start()
+ */
+public interface StandardParserConstants {
+
+ /** End of File. */
+ int EOF = 0;
+ /** RegularExpression Id. */
+ int LONE_SYMBOL = 1;
+ /** RegularExpression Id. */
+ int ZERO_WIDTH_WHITESPACE = 2;
+ /** RegularExpression Id. */
+ int INDEX_LBRACKET = 3;
+ /** RegularExpression Id. */
+ int LOGICAL_OR_2 = 4;
+ /** RegularExpression Id. */
+ int PIPE = 5;
+ /** RegularExpression Id. */
+ int INDEX_RBRACKET = 6;
+ /** RegularExpression Id. */
+ int LBRACKET = 7;
+ /** RegularExpression Id. */
+ int RBRACKET = 8;
+ /** RegularExpression Id. */
+ int COMMA = 9;
+ /** RegularExpression Id. */
+ int DOUBLEDOT = 10;
+ /** RegularExpression Id. */
+ int COLON = 11;
+ /** RegularExpression Id. */
+ int LEFT_CURLEY = 12;
+ /** RegularExpression Id. */
+ int RIGHT_CURLEY = 13;
+ /** RegularExpression Id. */
+ int LPAREN = 14;
+ /** RegularExpression Id. */
+ int RPAREN = 15;
+ /** RegularExpression Id. */
+ int REFMOD2_RPAREN = 16;
+ /** RegularExpression Id. */
+ int ESCAPE_DIRECTIVE = 17;
+ /** RegularExpression Id. */
+ int SET_DIRECTIVE = 18;
+ /** RegularExpression Id. */
+ int DOLLAR = 19;
+ /** RegularExpression Id. */
+ int DOLLARBANG = 20;
+ /** RegularExpression Id. */
+ int HASH = 24;
+ /** RegularExpression Id. */
+ int SINGLE_LINE_COMMENT_START = 25;
+ /** RegularExpression Id. */
+ int SINGLE_LINE_COMMENT = 26;
+ /** RegularExpression Id. */
+ int FORMAL_COMMENT = 27;
+ /** RegularExpression Id. */
+ int MULTI_LINE_COMMENT = 28;
+ /** RegularExpression Id. */
+ int TEXTBLOCK = 29;
+ /** RegularExpression Id. */
+ int WHITESPACE = 32;
+ /** RegularExpression Id. */
+ int NEWLINE = 33;
+ /** RegularExpression Id. */
+ int SUFFIX = 34;
+ /** RegularExpression Id. */
+ int STRING_LITERAL = 35;
+ /** RegularExpression Id. */
+ int TRUE = 36;
+ /** RegularExpression Id. */
+ int FALSE = 37;
+ /** RegularExpression Id. */
+ int MINUS = 38;
+ /** RegularExpression Id. */
+ int PLUS = 39;
+ /** RegularExpression Id. */
+ int MULTIPLY = 40;
+ /** RegularExpression Id. */
+ int DIVIDE = 41;
+ /** RegularExpression Id. */
+ int MODULUS = 42;
+ /** RegularExpression Id. */
+ int LOGICAL_AND = 43;
+ /** RegularExpression Id. */
+ int LOGICAL_OR = 44;
+ /** RegularExpression Id. */
+ int LOGICAL_LT = 45;
+ /** RegularExpression Id. */
+ int LOGICAL_LE = 46;
+ /** RegularExpression Id. */
+ int LOGICAL_GT = 47;
+ /** RegularExpression Id. */
+ int LOGICAL_GE = 48;
+ /** RegularExpression Id. */
+ int LOGICAL_EQUALS = 49;
+ /** RegularExpression Id. */
+ int LOGICAL_NOT_EQUALS = 50;
+ /** RegularExpression Id. */
+ int LOGICAL_NOT = 51;
+ /** RegularExpression Id. */
+ int EQUALS = 52;
+ /** RegularExpression Id. */
+ int END = 53;
+ /** RegularExpression Id. */
+ int IF_DIRECTIVE = 54;
+ /** RegularExpression Id. */
+ int ELSEIF = 55;
+ /** RegularExpression Id. */
+ int ELSE = 56;
+ /** RegularExpression Id. */
+ int DIGIT = 57;
+ /** RegularExpression Id. */
+ int INTEGER_LITERAL = 58;
+ /** RegularExpression Id. */
+ int FLOATING_POINT_LITERAL = 59;
+ /** RegularExpression Id. */
+ int EXPONENT = 60;
+ /** RegularExpression Id. */
+ int LETTER = 61;
+ /** RegularExpression Id. */
+ int DIRECTIVE_CHAR = 62;
+ /** RegularExpression Id. */
+ int WORD = 63;
+ /** RegularExpression Id. */
+ int BRACKETED_WORD = 64;
+ /** RegularExpression Id. */
+ int ALPHA_CHAR = 65;
+ /** RegularExpression Id. */
+ int IDENTIFIER_CHAR = 66;
+ /** RegularExpression Id. */
+ int IDENTIFIER = 67;
+ /** RegularExpression Id. */
+ int OLD_ALPHA_CHAR = 68;
+ /** RegularExpression Id. */
+ int OLD_IDENTIFIER_CHAR = 69;
+ /** RegularExpression Id. */
+ int OLD_IDENTIFIER = 70;
+ /** RegularExpression Id. */
+ int DOT = 71;
+ /** RegularExpression Id. */
+ int LCURLY = 72;
+ /** RegularExpression Id. */
+ int RCURLY = 73;
+ /** RegularExpression Id. */
+ int REFERENCE_TERMINATOR = 74;
+ /** RegularExpression Id. */
+ int DIRECTIVE_TERMINATOR = 75;
+ /** RegularExpression Id. */
+ int DOUBLE_ESCAPE = 76;
+ /** RegularExpression Id. */
+ int ESCAPE = 77;
+ /** RegularExpression Id. */
+ int TEXT = 78;
+ /** RegularExpression Id. */
+ int INLINE_TEXT = 79;
+ /** RegularExpression Id. */
+ int EMPTY_INDEX = 80;
+
+ /** Lexical state. */
+ int PRE_DIRECTIVE = 0;
+ /** Lexical state. */
+ int PRE_REFERENCE = 1;
+ /** Lexical state. */
+ int PRE_OLD_REFERENCE = 2;
+ /** Lexical state. */
+ int REFERENCE = 3;
+ /** Lexical state. */
+ int REFMODIFIER = 4;
+ /** Lexical state. */
+ int OLD_REFMODIFIER = 5;
+ /** Lexical state. */
+ int REFMOD3 = 6;
+ /** Lexical state. */
+ int REFINDEX = 7;
+ /** Lexical state. */
+ int DIRECTIVE = 8;
+ /** Lexical state. */
+ int REFMOD2 = 9;
+ /** Lexical state. */
+ int DEFAULT = 10;
+ /** Lexical state. */
+ int REFMOD = 11;
+ /** Lexical state. */
+ int IN_TEXTBLOCK = 12;
+ /** Lexical state. */
+ int IN_MULTILINE_COMMENT = 13;
+ /** Lexical state. */
+ int IN_FORMAL_COMMENT = 14;
+ /** Lexical state. */
+ int IN_SINGLE_LINE_COMMENT = 15;
+ /** Lexical state. */
+ int ALT_VAL = 16;
+ /** Lexical state. */
+ int IN_MULTI_LINE_COMMENT = 17;
+
+ /** Literal token values. */
+ String[] tokenImage = {
+ "<EOF>",
+ "\"\\u001c\"",
+ "\"\\u001c\"",
+ "\"[\"",
+ "\"||\"",
+ "\"|\"",
+ "\"]\"",
+ "\"[\"",
+ "\"]\"",
+ "\",\"",
+ "\"..\"",
+ "\":\"",
+ "\"{\"",
+ "\"}\"",
+ "\"(\"",
+ "\")\"",
+ "\")\"",
+ "<ESCAPE_DIRECTIVE>",
+ "<SET_DIRECTIVE>",
+ "<DOLLAR>",
+ "<DOLLARBANG>",
+ "\"#[[\"",
+ "<token of kind 22>",
+ "\"#*\"",
+ "\"#\"",
+ "\"##\"",
+ "<SINGLE_LINE_COMMENT>",
+ "\"*#\"",
+ "\"*#\"",
+ "\"]]#\"",
+ "<token of kind 30>",
+ "<token of kind 31>",
+ "<WHITESPACE>",
+ "<NEWLINE>",
+ "<SUFFIX>",
+ "<STRING_LITERAL>",
+ "\"true\"",
+ "\"false\"",
+ "\"-\"",
+ "\"+\"",
+ "\"*\"",
+ "\"/\"",
+ "\"%\"",
+ "<LOGICAL_AND>",
+ "<LOGICAL_OR>",
+ "<LOGICAL_LT>",
+ "<LOGICAL_LE>",
+ "<LOGICAL_GT>",
+ "<LOGICAL_GE>",
+ "<LOGICAL_EQUALS>",
+ "<LOGICAL_NOT_EQUALS>",
+ "<LOGICAL_NOT>",
+ "\"=\"",
+ "<END>",
+ "<IF_DIRECTIVE>",
+ "<ELSEIF>",
+ "<ELSE>",
+ "<DIGIT>",
+ "<INTEGER_LITERAL>",
+ "<FLOATING_POINT_LITERAL>",
+ "<EXPONENT>",
+ "<LETTER>",
+ "<DIRECTIVE_CHAR>",
+ "<WORD>",
+ "<BRACKETED_WORD>",
+ "<ALPHA_CHAR>",
+ "<IDENTIFIER_CHAR>",
+ "<IDENTIFIER>",
+ "<OLD_ALPHA_CHAR>",
+ "<OLD_IDENTIFIER_CHAR>",
+ "<OLD_IDENTIFIER>",
+ "<DOT>",
+ "\"{\"",
+ "\"}\"",
+ "<REFERENCE_TERMINATOR>",
+ "<DIRECTIVE_TERMINATOR>",
+ "\"\\\\\\\\\"",
+ "\"\\\\\"",
+ "<TEXT>",
+ "<INLINE_TEXT>",
+ "<EMPTY_INDEX>",
+ };
+
+}
diff --git a/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserTokenManager.java b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserTokenManager.java
new file mode 100644
index 0000000..82761fe
--- /dev/null
+++ b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserTokenManager.java
@@ -0,0 +1,8749 @@
+/* Generated By:JJTree&JavaCC: Do not edit this line. StandardParserTokenManager.java */
+package org.apache.velocity.runtime.parser;
+import org.apache.velocity.runtime.parser.node.*;
+import java.io.*;
+import java.util.*;
+import org.apache.velocity.Template;
+import org.apache.velocity.exception.VelocityException;
+import org.apache.velocity.runtime.RuntimeServices;
+import org.apache.velocity.runtime.parser.*;
+import org.apache.velocity.runtime.parser.node.*;
+import org.apache.velocity.runtime.directive.*;
+import org.apache.velocity.runtime.directive.MacroParseException;
+import org.apache.velocity.runtime.RuntimeConstants;
+import static org.apache.velocity.runtime.RuntimeConstants.SpaceGobbling;
+import org.slf4j.Logger;
+
+/** Token Manager. */
+public class StandardParserTokenManager implements StandardParserConstants
+{
+ private int fileDepth = 0;
+
+ private int lparen = 0;
+ private int rparen = 0;
+ private int curlyLevel = 0;
+ List stateStack = new ArrayList(50);
+
+ private boolean inComment;
+ private boolean inSet;
+
+ /**
+ * Our own trace method. Use sparsingly in production, since each
+ * and every call will introduce an execution branch and slow down parsing.
+ */
+ public static void trace(String message)
+ {
+ StandardParser.trace(message);
+ }
+
+ /**
+ * Switches to a new state (add some log to the default method)
+ */
+ public void switchTo(int lexState)
+ {
+ trace(" switch to " + lexStateNames[lexState]);
+ SwitchTo(lexState);
+ }
+
+ public int getCurrentLexicalState()
+ {
+ return curLexState;
+ }
+
+ /**
+ * pops a state off the stack, and restores paren counts
+ *
+ * @return boolean : success of operation
+ */
+ public boolean stateStackPop()
+ {
+ ParserState s;
+ try
+ {
+ s = (ParserState) stateStack.remove(stateStack.size() - 1); // stack.pop
+ }
+ catch(IndexOutOfBoundsException e)
+ {
+ // empty stack
+ lparen=0;
+ switchTo(DEFAULT);
+ return false;
+ }
+
+ trace(" stack pop (" + stateStack.size() + ")");
+ lparen = s.lparen;
+ rparen = s.rparen;
+ curlyLevel = s.curlyLevel;
+
+ switchTo(s.lexstate);
+
+ return true;
+ }
+
+ /**
+ * pushes the current state onto the 'state stack',
+ * and maintains the parens counts
+ * public because we need it in PD & VM handling
+ *
+ * @return boolean : success. It can fail if the state machine
+ * gets messed up (do don't mess it up :)
+ */
+ public boolean stateStackPush()
+ {
+ trace(" (" + stateStack.size() + ") pushing cur state : " + lexStateNames[curLexState] );
+
+ ParserState s = new ParserState();
+ s.lparen = lparen;
+ s.rparen = rparen;
+ s.curlyLevel = curlyLevel;
+ s.lexstate = curLexState;
+
+ stateStack.add(s); // stack.push
+
+ lparen = 0;
+ curlyLevel = 0;
+
+ return true;
+ }
+
+ /**
+ * Clears all state variables, resets to
+ * start values, clears stateStack. Call
+ * before parsing.
+ */
+ public void clearStateVars()
+ {
+ stateStack.clear();
+
+ lparen = 0;
+ rparen = 0;
+ curlyLevel = 0;
+ inComment = false;
+ inSet = false;
+
+ return;
+ }
+
+ public void setInSet(boolean value)
+ {
+ inSet = value;
+ }
+
+ public boolean isInSet()
+ {
+ return inSet;
+ }
+
+ /**
+ * Holds the state of the parsing process.
+ */
+ private static class ParserState
+ {
+ int lparen;
+ int rparen;
+ int curlyLevel;
+ int lexstate;
+ }
+
+ /**
+ * handles the dropdown logic when encountering a RPAREN
+ */
+ private void RPARENHandler()
+ {
+ /*
+ * Ultimately, we want to drop down to the state below
+ * the one that has an open (if we hit bottom (DEFAULT),
+ * that's fine. It's just text schmoo.
+ */
+
+ boolean closed = false;
+
+ if (inComment)
+ closed = true;
+
+ while( !closed )
+ {
+ /*
+ * look at current state. If we haven't seen a lparen
+ * in this state then we drop a state, because this
+ * lparen clearly closes our state
+ */
+
+ if( lparen > 0)
+ {
+ /*
+ * if rparen + 1 == lparen, then this state is closed.
+ * Otherwise, increment and keep parsing
+ */
+
+ if( lparen == rparen + 1)
+ {
+ stateStackPop();
+ }
+ else
+ {
+ rparen++;
+ }
+
+ closed = true;
+ }
+ else
+ {
+ /*
+ * now, drop a state
+ */
+
+ if(!stateStackPop())
+ break;
+ }
+ }
+ }
+
+ /** Debug output. */
+ public java.io.PrintStream debugStream = System.out;
+ /** Set debug output. */
+ public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
+
+ /** The parser. */
+ public StandardParser parser = null;
+private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x3a00000L) != 0L)
+ return 15;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 21;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_3(int pos, long active0, long active1)
+{
+ return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1), pos + 1);
+}
+private int jjStopAtPos(int pos, int kind)
+{
+ jjmatchedKind = kind;
+ jjmatchedPos = pos;
+ return pos + 1;
+}
+private int jjMoveStringLiteralDfa0_3()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_3(0x2a00000L);
+ case 91:
+ return jjStopAtPos(0, 3);
+ case 102:
+ return jjMoveStringLiteralDfa1_3(0x2000000000L);
+ case 116:
+ return jjMoveStringLiteralDfa1_3(0x1000000000L);
+ case 123:
+ return jjStopAtPos(0, 72);
+ case 124:
+ jjmatchedKind = 5;
+ return jjMoveStringLiteralDfa1_3(0x10L);
+ case 125:
+ return jjStopAtPos(0, 73);
+ default :
+ return jjMoveNfa_3(0, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_3(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_3(0, active0, 0L);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x2000000L) != 0L)
+ return jjStopAtPos(1, 25);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_3(1, 23, 21);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_3(active0, 0x200000L);
+ case 97:
+ return jjMoveStringLiteralDfa2_3(active0, 0x2000000000L);
+ case 114:
+ return jjMoveStringLiteralDfa2_3(active0, 0x1000000000L);
+ case 124:
+ if ((active0 & 0x10L) != 0L)
+ return jjStopAtPos(1, 4);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_3(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_3(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_3(0, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_3(1, active0, 0L);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ case 108:
+ return jjMoveStringLiteralDfa3_3(active0, 0x2000000000L);
+ case 117:
+ return jjMoveStringLiteralDfa3_3(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_3(1, active0, 0L);
+}
+private int jjMoveStringLiteralDfa3_3(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_3(1, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_3(2, active0, 0L);
+ return 3;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x1000000000L) != 0L)
+ return jjStopAtPos(3, 36);
+ break;
+ case 115:
+ return jjMoveStringLiteralDfa4_3(active0, 0x2000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_3(2, active0, 0L);
+}
+private int jjMoveStringLiteralDfa4_3(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_3(2, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_3(3, active0, 0L);
+ return 4;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x2000000000L) != 0L)
+ return jjStopAtPos(4, 37);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_3(3, active0, 0L);
+}
+private int jjStartNfaWithStates_3(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_3(state, pos + 1);
+}
+static final long[] jjbitVec0 = {
+ 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+static final long[] jjbitVec2 = {
+ 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+private int jjMoveNfa_3(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 24;
+ 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 0:
+ if (curChar == 35)
+ jjAddStates(0, 2);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(7, 8);
+ }
+ else if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 15:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 4:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 6:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 8:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 9:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 10:
+ if (curChar == 35)
+ jjAddStates(0, 2);
+ break;
+ case 12:
+ if ((0x100000200L & l) != 0L)
+ jjAddStates(3, 4);
+ break;
+ case 13:
+ if (curChar == 40 && kind > 18)
+ kind = 18;
+ break;
+ case 21:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 22;
+ break;
+ case 22:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 0:
+ if (curChar == 92)
+ jjCheckNAddStates(5, 8);
+ break;
+ case 15:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 19;
+ else if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 14;
+ break;
+ case 1:
+ if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
+ kind = 71;
+ break;
+ case 3:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(3, 4);
+ break;
+ case 5:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(5, 6);
+ break;
+ case 7:
+ if (curChar == 92)
+ jjAddStates(9, 10);
+ break;
+ case 11:
+ if (curChar == 116)
+ jjCheckNAddTwoStates(12, 13);
+ break;
+ case 14:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 11;
+ break;
+ case 16:
+ if (curChar == 125)
+ jjCheckNAddTwoStates(12, 13);
+ break;
+ case 17:
+ if (curChar == 116)
+ jjstateSet[jjnewStateCnt++] = 16;
+ break;
+ case 18:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 17;
+ break;
+ case 19:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 18;
+ break;
+ case 20:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 19;
+ break;
+ case 22:
+ if (kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 22:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 24 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_0(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x3a00000L) != 0L)
+ return 2;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 0;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_0(int pos, long active0)
+{
+ return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_0()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 1);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_0(0x2a00000L);
+ default :
+ return jjMoveNfa_0(3, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_0(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_0(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x2000000L) != 0L)
+ return jjStopAtPos(1, 25);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_0(1, 23, 0);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_0(active0, 0x200000L);
+ default :
+ break;
+ }
+ return jjStartNfa_0(0, active0);
+}
+private int jjMoveStringLiteralDfa2_0(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_0(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_0(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_0(1, active0);
+}
+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);
+}
+private int jjMoveNfa_0(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 75;
+ 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 3:
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddStates(11, 16);
+ }
+ else if ((0x2400L & l) != 0L)
+ {
+ if (kind > 34)
+ kind = 34;
+ }
+ else if ((0x100000200L & l) != 0L)
+ jjCheckNAddStates(17, 19);
+ else if (curChar == 45)
+ jjCheckNAddStates(20, 23);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(26, 27);
+ }
+ else if (curChar == 46)
+ jjCheckNAdd(11);
+ else if (curChar == 35)
+ jjstateSet[jjnewStateCnt++] = 2;
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 0:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 1:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 2:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 0;
+ break;
+ case 4:
+ if ((0x100000200L & l) != 0L)
+ jjCheckNAddStates(17, 19);
+ break;
+ case 5:
+ if ((0x2400L & l) != 0L && kind > 34)
+ kind = 34;
+ break;
+ case 6:
+ if (curChar == 10 && kind > 34)
+ kind = 34;
+ break;
+ case 7:
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 10:
+ if (curChar == 46)
+ jjCheckNAdd(11);
+ break;
+ case 11:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(11, 12);
+ break;
+ case 13:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(14);
+ break;
+ case 14:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(14);
+ break;
+ case 16:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 63)
+ kind = 63;
+ jjstateSet[jjnewStateCnt++] = 16;
+ break;
+ case 19:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjAddStates(24, 25);
+ break;
+ case 23:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 25:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(26, 27);
+ break;
+ case 27:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 28:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(26, 27);
+ break;
+ case 60:
+ if (curChar == 45)
+ jjCheckNAddStates(20, 23);
+ break;
+ case 61:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddTwoStates(61, 63);
+ break;
+ case 62:
+ if (curChar == 46 && kind > 58)
+ kind = 58;
+ break;
+ case 63:
+ if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 62;
+ break;
+ case 64:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(64, 65);
+ break;
+ case 65:
+ if (curChar != 46)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(66, 67);
+ break;
+ case 66:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(66, 67);
+ break;
+ case 68:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(69);
+ break;
+ case 69:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(69);
+ break;
+ case 70:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(70, 71);
+ break;
+ case 72:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(73);
+ break;
+ case 73:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(73);
+ break;
+ case 74:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddStates(11, 16);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 3:
+ if ((0x7fffffe87ffffffL & l) != 0L)
+ {
+ if (kind > 63)
+ kind = 63;
+ jjCheckNAdd(16);
+ }
+ else if (curChar == 123)
+ jjAddStates(26, 29);
+ else if (curChar == 92)
+ jjCheckNAddStates(30, 33);
+ if (curChar == 101)
+ jjAddStates(34, 36);
+ else if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 18;
+ else if (curChar == 105)
+ jjstateSet[jjnewStateCnt++] = 8;
+ break;
+ case 1:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 8:
+ if (curChar == 102 && kind > 54)
+ kind = 54;
+ break;
+ case 9:
+ if (curChar == 105)
+ jjstateSet[jjnewStateCnt++] = 8;
+ break;
+ case 12:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(37, 38);
+ break;
+ case 15:
+ if ((0x7fffffe87ffffffL & l) == 0L)
+ break;
+ if (kind > 63)
+ kind = 63;
+ jjCheckNAdd(16);
+ break;
+ case 16:
+ if ((0x7fffffe87fffffeL & l) == 0L)
+ break;
+ if (kind > 63)
+ kind = 63;
+ jjCheckNAdd(16);
+ break;
+ case 17:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 18;
+ break;
+ case 18:
+ if ((0x7fffffe87ffffffL & l) != 0L)
+ jjCheckNAddTwoStates(19, 20);
+ break;
+ case 19:
+ if ((0x7fffffe87fffffeL & l) != 0L)
+ jjCheckNAddTwoStates(19, 20);
+ break;
+ case 20:
+ if (curChar == 125 && kind > 64)
+ kind = 64;
+ break;
+ case 21:
+ if (curChar == 92)
+ jjCheckNAddStates(30, 33);
+ break;
+ case 22:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(22, 23);
+ break;
+ case 24:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(24, 25);
+ break;
+ case 26:
+ if (curChar == 92)
+ jjAddStates(39, 40);
+ break;
+ case 29:
+ if (curChar == 101)
+ jjAddStates(34, 36);
+ break;
+ case 30:
+ if (curChar == 100 && kind > 53)
+ kind = 53;
+ break;
+ case 31:
+ if (curChar == 110)
+ jjstateSet[jjnewStateCnt++] = 30;
+ break;
+ case 32:
+ if (curChar == 102 && kind > 55)
+ kind = 55;
+ break;
+ case 33:
+ if (curChar == 105)
+ jjstateSet[jjnewStateCnt++] = 32;
+ break;
+ case 34:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 33;
+ break;
+ case 35:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 34;
+ break;
+ case 36:
+ if (curChar == 108)
+ jjstateSet[jjnewStateCnt++] = 35;
+ break;
+ case 37:
+ if (curChar == 101 && kind > 56)
+ kind = 56;
+ break;
+ case 38:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 37;
+ break;
+ case 39:
+ if (curChar == 108)
+ jjstateSet[jjnewStateCnt++] = 38;
+ break;
+ case 40:
+ if (curChar == 123)
+ jjAddStates(26, 29);
+ break;
+ case 41:
+ if (curChar == 125 && kind > 53)
+ kind = 53;
+ break;
+ case 42:
+ if (curChar == 100)
+ jjstateSet[jjnewStateCnt++] = 41;
+ break;
+ case 43:
+ if (curChar == 110)
+ jjstateSet[jjnewStateCnt++] = 42;
+ break;
+ case 44:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 43;
+ break;
+ case 45:
+ if (curChar == 125 && kind > 54)
+ kind = 54;
+ break;
+ case 46:
+ if (curChar == 102)
+ jjstateSet[jjnewStateCnt++] = 45;
+ break;
+ case 47:
+ if (curChar == 105)
+ jjstateSet[jjnewStateCnt++] = 46;
+ break;
+ case 48:
+ if (curChar == 125 && kind > 55)
+ kind = 55;
+ break;
+ case 49:
+ if (curChar == 102)
+ jjstateSet[jjnewStateCnt++] = 48;
+ break;
+ case 50:
+ if (curChar == 105)
+ jjstateSet[jjnewStateCnt++] = 49;
+ break;
+ case 51:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 50;
+ break;
+ case 52:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 51;
+ break;
+ case 53:
+ if (curChar == 108)
+ jjstateSet[jjnewStateCnt++] = 52;
+ break;
+ case 54:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 53;
+ break;
+ case 55:
+ if (curChar == 125 && kind > 56)
+ kind = 56;
+ break;
+ case 56:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 55;
+ break;
+ case 57:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 56;
+ break;
+ case 58:
+ if (curChar == 108)
+ jjstateSet[jjnewStateCnt++] = 57;
+ break;
+ case 59:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 58;
+ break;
+ case 67:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(41, 42);
+ break;
+ case 71:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(43, 44);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_16(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x4000000000L) != 0L)
+ return 94;
+ if ((active0 & 0x1a00000L) != 0L)
+ return 2;
+ if ((active0 & 0x400L) != 0L)
+ return 57;
+ if ((active0 & 0x10000000000000L) != 0L)
+ return 49;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 0;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_16(int pos, long active0)
+{
+ return jjMoveNfa_16(jjStopStringLiteralDfa_16(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_16()
+{
+ switch(curChar)
+ {
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_16(0xa00000L);
+ case 37:
+ return jjStopAtPos(0, 42);
+ case 42:
+ return jjStopAtPos(0, 40);
+ case 43:
+ return jjStopAtPos(0, 39);
+ case 44:
+ return jjStopAtPos(0, 9);
+ case 45:
+ return jjStartNfaWithStates_16(0, 38, 94);
+ case 46:
+ return jjMoveStringLiteralDfa1_16(0x400L);
+ case 47:
+ return jjStopAtPos(0, 41);
+ case 58:
+ return jjStopAtPos(0, 11);
+ case 61:
+ return jjStartNfaWithStates_16(0, 52, 49);
+ case 91:
+ return jjStopAtPos(0, 7);
+ case 93:
+ return jjStopAtPos(0, 8);
+ case 102:
+ return jjMoveStringLiteralDfa1_16(0x2000000000L);
+ case 116:
+ return jjMoveStringLiteralDfa1_16(0x1000000000L);
+ case 123:
+ return jjStopAtPos(0, 12);
+ case 125:
+ return jjStopAtPos(0, 13);
+ default :
+ return jjMoveNfa_16(3, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_16(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_16(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_16(1, 23, 0);
+ break;
+ case 46:
+ if ((active0 & 0x400L) != 0L)
+ return jjStopAtPos(1, 10);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_16(active0, 0x200000L);
+ case 97:
+ return jjMoveStringLiteralDfa2_16(active0, 0x2000000000L);
+ case 114:
+ return jjMoveStringLiteralDfa2_16(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_16(0, active0);
+}
+private int jjMoveStringLiteralDfa2_16(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_16(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_16(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ case 108:
+ return jjMoveStringLiteralDfa3_16(active0, 0x2000000000L);
+ case 117:
+ return jjMoveStringLiteralDfa3_16(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_16(1, active0);
+}
+private int jjMoveStringLiteralDfa3_16(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_16(1, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_16(2, active0);
+ return 3;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x1000000000L) != 0L)
+ return jjStopAtPos(3, 36);
+ break;
+ case 115:
+ return jjMoveStringLiteralDfa4_16(active0, 0x2000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_16(2, active0);
+}
+private int jjMoveStringLiteralDfa4_16(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_16(2, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_16(3, active0);
+ return 4;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x2000000000L) != 0L)
+ return jjStopAtPos(4, 37);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_16(3, active0);
+}
+private int jjStartNfaWithStates_16(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_16(state, pos + 1);
+}
+private int jjMoveNfa_16(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 94;
+ 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 94:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(89, 90);
+ else if (curChar == 46)
+ jjCheckNAdd(57);
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(83, 84);
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddTwoStates(80, 82);
+ }
+ break;
+ case 3:
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddStates(45, 50);
+ }
+ else if ((0x2400L & l) != 0L)
+ {
+ if (kind > 33)
+ kind = 33;
+ }
+ else if ((0x100000200L & l) != 0L)
+ {
+ if (kind > 32)
+ kind = 32;
+ jjCheckNAdd(4);
+ }
+ else if (curChar == 45)
+ jjCheckNAddStates(51, 54);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(66, 67);
+ }
+ else if (curChar == 46)
+ jjCheckNAdd(57);
+ else if (curChar == 33)
+ {
+ if (kind > 51)
+ kind = 51;
+ }
+ else if (curChar == 61)
+ jjstateSet[jjnewStateCnt++] = 49;
+ else if (curChar == 62)
+ jjstateSet[jjnewStateCnt++] = 47;
+ else if (curChar == 60)
+ jjstateSet[jjnewStateCnt++] = 44;
+ else if (curChar == 38)
+ jjstateSet[jjnewStateCnt++] = 34;
+ else if (curChar == 39)
+ jjCheckNAddStates(55, 58);
+ else if (curChar == 34)
+ jjCheckNAddStates(59, 62);
+ else if (curChar == 35)
+ jjstateSet[jjnewStateCnt++] = 2;
+ if (curChar == 33)
+ jjstateSet[jjnewStateCnt++] = 53;
+ else if (curChar == 62)
+ {
+ if (kind > 47)
+ kind = 47;
+ }
+ else if (curChar == 60)
+ {
+ if (kind > 45)
+ kind = 45;
+ }
+ else if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 0:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 1:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 2:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 0;
+ break;
+ case 4:
+ if ((0x100000200L & l) == 0L)
+ break;
+ if (kind > 32)
+ kind = 32;
+ jjCheckNAdd(4);
+ break;
+ case 5:
+ if ((0x2400L & l) != 0L && kind > 33)
+ kind = 33;
+ break;
+ case 6:
+ if (curChar == 10 && kind > 33)
+ kind = 33;
+ break;
+ case 7:
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 8:
+ case 10:
+ if (curChar == 34)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 9:
+ if ((0xfffffffbefffffffL & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 11:
+ if (curChar == 34)
+ jjstateSet[jjnewStateCnt++] = 10;
+ break;
+ case 12:
+ if (curChar == 34 && kind > 35)
+ kind = 35;
+ break;
+ case 15:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAddStates(63, 67);
+ break;
+ case 16:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 17:
+ if ((0xf000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 18;
+ break;
+ case 18:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAdd(16);
+ break;
+ case 20:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 21:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 22;
+ break;
+ case 22:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 23;
+ break;
+ case 23:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 24:
+ if (curChar == 32)
+ jjAddStates(68, 69);
+ break;
+ case 25:
+ if (curChar == 10)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 26:
+ case 28:
+ if (curChar == 39)
+ jjCheckNAddStates(55, 58);
+ break;
+ case 27:
+ if ((0xffffff7fefffffffL & l) != 0L)
+ jjCheckNAddStates(55, 58);
+ break;
+ case 29:
+ if (curChar == 39)
+ jjstateSet[jjnewStateCnt++] = 28;
+ break;
+ case 31:
+ if (curChar == 32)
+ jjAddStates(70, 71);
+ break;
+ case 32:
+ if (curChar == 10)
+ jjCheckNAddStates(55, 58);
+ break;
+ case 33:
+ if (curChar == 39 && kind > 35)
+ kind = 35;
+ break;
+ case 34:
+ if (curChar == 38 && kind > 43)
+ kind = 43;
+ break;
+ case 35:
+ if (curChar == 38)
+ jjstateSet[jjnewStateCnt++] = 34;
+ break;
+ case 43:
+ if (curChar == 60 && kind > 45)
+ kind = 45;
+ break;
+ case 44:
+ if (curChar == 61 && kind > 46)
+ kind = 46;
+ break;
+ case 45:
+ if (curChar == 60)
+ jjstateSet[jjnewStateCnt++] = 44;
+ break;
+ case 46:
+ if (curChar == 62 && kind > 47)
+ kind = 47;
+ break;
+ case 47:
+ if (curChar == 61 && kind > 48)
+ kind = 48;
+ break;
+ case 48:
+ if (curChar == 62)
+ jjstateSet[jjnewStateCnt++] = 47;
+ break;
+ case 49:
+ if (curChar == 61 && kind > 49)
+ kind = 49;
+ break;
+ case 50:
+ if (curChar == 61)
+ jjstateSet[jjnewStateCnt++] = 49;
+ break;
+ case 53:
+ if (curChar == 61 && kind > 50)
+ kind = 50;
+ break;
+ case 54:
+ if (curChar == 33)
+ jjstateSet[jjnewStateCnt++] = 53;
+ break;
+ case 55:
+ if (curChar == 33 && kind > 51)
+ kind = 51;
+ break;
+ case 56:
+ if (curChar == 46)
+ jjCheckNAdd(57);
+ break;
+ case 57:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(57, 58);
+ break;
+ case 59:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(60);
+ break;
+ case 60:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(60);
+ break;
+ case 63:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 65:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(66, 67);
+ break;
+ case 67:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 68:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(66, 67);
+ break;
+ case 79:
+ if (curChar == 45)
+ jjCheckNAddStates(51, 54);
+ break;
+ case 80:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddTwoStates(80, 82);
+ break;
+ case 81:
+ if (curChar == 46 && kind > 58)
+ kind = 58;
+ break;
+ case 82:
+ if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 81;
+ break;
+ case 83:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(83, 84);
+ break;
+ case 84:
+ if (curChar != 46)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(85, 86);
+ break;
+ case 85:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(85, 86);
+ break;
+ case 87:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(88);
+ break;
+ case 88:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(88);
+ break;
+ case 89:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(89, 90);
+ break;
+ case 91:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(92);
+ break;
+ case 92:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(92);
+ break;
+ case 93:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddStates(45, 50);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 3:
+ if (curChar == 110)
+ jjAddStates(72, 73);
+ else if (curChar == 103)
+ jjAddStates(74, 75);
+ else if (curChar == 108)
+ jjAddStates(76, 77);
+ else if (curChar == 92)
+ jjCheckNAddStates(78, 81);
+ else if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 51;
+ else if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 41;
+ else if (curChar == 124)
+ jjstateSet[jjnewStateCnt++] = 39;
+ else if (curChar == 97)
+ jjstateSet[jjnewStateCnt++] = 37;
+ break;
+ case 1:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 9:
+ jjCheckNAddStates(59, 62);
+ break;
+ case 13:
+ if (curChar == 92)
+ jjAddStates(82, 87);
+ break;
+ case 14:
+ if ((0x14404400000000L & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 19:
+ if (curChar == 117)
+ jjstateSet[jjnewStateCnt++] = 20;
+ break;
+ case 20:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 21:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 22;
+ break;
+ case 22:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 23;
+ break;
+ case 23:
+ if ((0x7e0000007eL & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 27:
+ jjAddStates(55, 58);
+ break;
+ case 30:
+ if (curChar == 92)
+ jjAddStates(70, 71);
+ break;
+ case 36:
+ if (curChar == 100 && kind > 43)
+ kind = 43;
+ break;
+ case 37:
+ if (curChar == 110)
+ jjstateSet[jjnewStateCnt++] = 36;
+ break;
+ case 38:
+ if (curChar == 97)
+ jjstateSet[jjnewStateCnt++] = 37;
+ break;
+ case 39:
+ if (curChar == 124 && kind > 44)
+ kind = 44;
+ break;
+ case 40:
+ if (curChar == 124)
+ jjstateSet[jjnewStateCnt++] = 39;
+ break;
+ case 41:
+ if (curChar == 114 && kind > 44)
+ kind = 44;
+ break;
+ case 42:
+ if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 41;
+ break;
+ case 51:
+ if (curChar == 113 && kind > 49)
+ kind = 49;
+ break;
+ case 52:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 51;
+ break;
+ case 58:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(88, 89);
+ break;
+ case 61:
+ if (curChar == 92)
+ jjCheckNAddStates(78, 81);
+ break;
+ case 62:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(62, 63);
+ break;
+ case 64:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(64, 65);
+ break;
+ case 66:
+ if (curChar == 92)
+ jjAddStates(90, 91);
+ break;
+ case 69:
+ if (curChar == 108)
+ jjAddStates(76, 77);
+ break;
+ case 70:
+ if (curChar == 116 && kind > 45)
+ kind = 45;
+ break;
+ case 71:
+ if (curChar == 101 && kind > 46)
+ kind = 46;
+ break;
+ case 72:
+ if (curChar == 103)
+ jjAddStates(74, 75);
+ break;
+ case 73:
+ if (curChar == 116 && kind > 47)
+ kind = 47;
+ break;
+ case 74:
+ if (curChar == 101 && kind > 48)
+ kind = 48;
+ break;
+ case 75:
+ if (curChar == 110)
+ jjAddStates(72, 73);
+ break;
+ case 76:
+ if (curChar == 101 && kind > 50)
+ kind = 50;
+ break;
+ case 77:
+ if (curChar == 116 && kind > 51)
+ kind = 51;
+ break;
+ case 78:
+ if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 77;
+ break;
+ case 86:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(92, 93);
+ break;
+ case 90:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(94, 95);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ case 9:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(59, 62);
+ break;
+ case 27:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(55, 58);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 94 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_12(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x1a00000L) != 0L)
+ return 2;
+ if ((active0 & 0x20000000L) != 0L)
+ {
+ jjmatchedKind = 31;
+ return -1;
+ }
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 0;
+ if ((active0 & 0x20000000L) != 0L)
+ {
+ if (jjmatchedPos == 0)
+ {
+ jjmatchedKind = 31;
+ jjmatchedPos = 0;
+ }
+ return -1;
+ }
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_12(int pos, long active0)
+{
+ return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_12()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_12(0xa00000L);
+ case 93:
+ return jjMoveStringLiteralDfa1_12(0x20000000L);
+ default :
+ return jjMoveNfa_12(3, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_12(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_12(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_12(1, 23, 0);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_12(active0, 0x200000L);
+ case 93:
+ return jjMoveStringLiteralDfa2_12(active0, 0x20000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_12(0, active0);
+}
+private int jjMoveStringLiteralDfa2_12(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_12(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_12(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x20000000L) != 0L)
+ return jjStopAtPos(2, 29);
+ break;
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_12(1, active0);
+}
+private int jjStartNfaWithStates_12(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_12(state, pos + 1);
+}
+private int jjMoveNfa_12(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 13;
+ 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 3:
+ if ((0xffffffffefffffffL & l) != 0L)
+ {
+ if (kind > 31)
+ kind = 31;
+ }
+ if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(10, 11);
+ }
+ else if (curChar == 35)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 0:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 1:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 2:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 0;
+ break;
+ case 4:
+ if ((0xffffffffefffffffL & l) != 0L && kind > 31)
+ kind = 31;
+ break;
+ case 7:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 9:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(10, 11);
+ break;
+ case 11:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 12:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(10, 11);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 3:
+ if (kind > 31)
+ kind = 31;
+ if (curChar == 92)
+ jjCheckNAddStates(96, 99);
+ break;
+ case 1:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 4:
+ if (kind > 31)
+ kind = 31;
+ break;
+ case 5:
+ if (curChar == 92)
+ jjCheckNAddStates(96, 99);
+ break;
+ case 6:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(6, 7);
+ break;
+ case 8:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(8, 9);
+ break;
+ case 10:
+ if (curChar == 92)
+ jjAddStates(100, 101);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 3:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 31)
+ kind = 31;
+ break;
+ case 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_15(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x1a00000L) != 0L)
+ return 2;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 0;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_15(int pos, long active0)
+{
+ return jjMoveNfa_15(jjStopStringLiteralDfa_15(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_15()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_15(0xa00000L);
+ default :
+ return jjMoveNfa_15(3, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_15(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_15(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_15(1, 23, 0);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_15(active0, 0x200000L);
+ default :
+ break;
+ }
+ return jjStartNfa_15(0, active0);
+}
+private int jjMoveStringLiteralDfa2_15(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_15(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_15(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_15(1, active0);
+}
+private int jjStartNfaWithStates_15(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_15(state, pos + 1);
+}
+private int jjMoveNfa_15(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 15;
+ 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 3:
+ if ((0x2400L & l) != 0L)
+ {
+ if (kind > 26)
+ kind = 26;
+ }
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(12, 13);
+ }
+ else if (curChar == 35)
+ jjstateSet[jjnewStateCnt++] = 2;
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 5;
+ break;
+ case 0:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 1:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 2:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 0;
+ break;
+ case 4:
+ if ((0x2400L & l) != 0L && kind > 26)
+ kind = 26;
+ break;
+ case 5:
+ if (curChar == 10 && kind > 26)
+ kind = 26;
+ break;
+ case 6:
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 5;
+ break;
+ case 9:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 11:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(12, 13);
+ break;
+ case 13:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 14:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(12, 13);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 3:
+ if (curChar == 92)
+ jjCheckNAddStates(102, 105);
+ break;
+ case 1:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 8:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(8, 9);
+ break;
+ case 10:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(10, 11);
+ break;
+ case 12:
+ if (curChar == 92)
+ jjAddStates(3, 4);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_5(int pos, long active0, long active1)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 70;
+ return 1;
+ }
+ if ((active0 & 0x3a00000L) != 0L)
+ return 17;
+ return -1;
+ case 1:
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 70;
+ jjmatchedPos = 1;
+ return 1;
+ }
+ if ((active0 & 0x800000L) != 0L)
+ return 23;
+ return -1;
+ case 2:
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 70;
+ jjmatchedPos = 2;
+ return 1;
+ }
+ return -1;
+ case 3:
+ if ((active0 & 0x2000000000L) != 0L)
+ {
+ jjmatchedKind = 70;
+ jjmatchedPos = 3;
+ return 1;
+ }
+ if ((active0 & 0x1000000000L) != 0L)
+ return 1;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_5(int pos, long active0, long active1)
+{
+ return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_5()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_5(0x2a00000L);
+ case 40:
+ return jjStopAtPos(0, 14);
+ case 91:
+ return jjStopAtPos(0, 3);
+ case 102:
+ return jjMoveStringLiteralDfa1_5(0x2000000000L);
+ case 116:
+ return jjMoveStringLiteralDfa1_5(0x1000000000L);
+ case 123:
+ return jjStopAtPos(0, 72);
+ case 124:
+ jjmatchedKind = 5;
+ return jjMoveStringLiteralDfa1_5(0x10L);
+ case 125:
+ return jjStopAtPos(0, 73);
+ default :
+ return jjMoveNfa_5(0, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_5(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_5(0, active0, 0L);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x2000000L) != 0L)
+ return jjStopAtPos(1, 25);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_5(1, 23, 23);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_5(active0, 0x200000L);
+ case 97:
+ return jjMoveStringLiteralDfa2_5(active0, 0x2000000000L);
+ case 114:
+ return jjMoveStringLiteralDfa2_5(active0, 0x1000000000L);
+ case 124:
+ if ((active0 & 0x10L) != 0L)
+ return jjStopAtPos(1, 4);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_5(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_5(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_5(0, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_5(1, active0, 0L);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ case 108:
+ return jjMoveStringLiteralDfa3_5(active0, 0x2000000000L);
+ case 117:
+ return jjMoveStringLiteralDfa3_5(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_5(1, active0, 0L);
+}
+private int jjMoveStringLiteralDfa3_5(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_5(1, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_5(2, active0, 0L);
+ return 3;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x1000000000L) != 0L)
+ return jjStartNfaWithStates_5(3, 36, 1);
+ break;
+ case 115:
+ return jjMoveStringLiteralDfa4_5(active0, 0x2000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_5(2, active0, 0L);
+}
+private int jjMoveStringLiteralDfa4_5(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_5(2, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_5(3, active0, 0L);
+ return 4;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x2000000000L) != 0L)
+ return jjStartNfaWithStates_5(4, 37, 1);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_5(3, active0, 0L);
+}
+private int jjStartNfaWithStates_5(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_5(state, pos + 1);
+}
+private int jjMoveNfa_5(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 26;
+ 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 0:
+ if (curChar == 35)
+ jjAddStates(106, 108);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ }
+ else if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 3;
+ break;
+ case 17:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 23;
+ break;
+ case 1:
+ if ((0x3ff200000000000L & l) == 0L)
+ break;
+ if (kind > 70)
+ kind = 70;
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 2:
+ if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 3;
+ break;
+ case 6:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 8:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ case 10:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 11:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ case 12:
+ if (curChar == 35)
+ jjAddStates(106, 108);
+ break;
+ case 14:
+ if ((0x100000200L & l) != 0L)
+ jjAddStates(109, 110);
+ break;
+ case 15:
+ if (curChar == 40 && kind > 18)
+ kind = 18;
+ break;
+ case 23:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 24;
+ break;
+ case 24:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 0:
+ if ((0x7fffffe87fffffeL & l) != 0L)
+ {
+ if (kind > 70)
+ kind = 70;
+ jjCheckNAdd(1);
+ }
+ else if (curChar == 92)
+ jjCheckNAddStates(111, 114);
+ break;
+ case 17:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 21;
+ else if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 16;
+ break;
+ case 1:
+ if ((0x7fffffe87fffffeL & l) == 0L)
+ break;
+ if (kind > 70)
+ kind = 70;
+ jjCheckNAdd(1);
+ break;
+ case 3:
+ if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
+ kind = 71;
+ break;
+ case 4:
+ if (curChar == 92)
+ jjCheckNAddStates(111, 114);
+ break;
+ case 5:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(5, 6);
+ break;
+ case 7:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 9:
+ if (curChar == 92)
+ jjAddStates(115, 116);
+ break;
+ case 13:
+ if (curChar == 116)
+ jjCheckNAddTwoStates(14, 15);
+ break;
+ case 16:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 13;
+ break;
+ case 18:
+ if (curChar == 125)
+ jjCheckNAddTwoStates(14, 15);
+ break;
+ case 19:
+ if (curChar == 116)
+ jjstateSet[jjnewStateCnt++] = 18;
+ break;
+ case 20:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 19;
+ break;
+ case 21:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 20;
+ break;
+ case 22:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 24:
+ if (kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 24:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 26 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_8(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x3a00000L) != 0L)
+ return 2;
+ if ((active0 & 0x400L) != 0L)
+ return 57;
+ if ((active0 & 0x4000000000L) != 0L)
+ return 100;
+ if ((active0 & 0x10000000000000L) != 0L)
+ return 49;
+ if ((active0 & 0x1000L) != 0L)
+ return 64;
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 63;
+ return 62;
+ }
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 0;
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 63;
+ jjmatchedPos = 1;
+ return 62;
+ }
+ return -1;
+ case 2:
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 63;
+ jjmatchedPos = 2;
+ return 62;
+ }
+ return -1;
+ case 3:
+ if ((active0 & 0x1000000000L) != 0L)
+ return 62;
+ if ((active0 & 0x2000000000L) != 0L)
+ {
+ jjmatchedKind = 63;
+ jjmatchedPos = 3;
+ return 62;
+ }
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_8(int pos, long active0)
+{
+ return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_8()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_8(0x2a00000L);
+ case 37:
+ return jjStopAtPos(0, 42);
+ case 40:
+ return jjStopAtPos(0, 14);
+ case 41:
+ return jjStopAtPos(0, 15);
+ case 42:
+ return jjStopAtPos(0, 40);
+ case 43:
+ return jjStopAtPos(0, 39);
+ case 44:
+ return jjStopAtPos(0, 9);
+ case 45:
+ return jjStartNfaWithStates_8(0, 38, 100);
+ case 46:
+ return jjMoveStringLiteralDfa1_8(0x400L);
+ case 47:
+ return jjStopAtPos(0, 41);
+ case 58:
+ return jjStopAtPos(0, 11);
+ case 61:
+ return jjStartNfaWithStates_8(0, 52, 49);
+ case 91:
+ return jjStopAtPos(0, 7);
+ case 93:
+ return jjStopAtPos(0, 8);
+ case 102:
+ return jjMoveStringLiteralDfa1_8(0x2000000000L);
+ case 116:
+ return jjMoveStringLiteralDfa1_8(0x1000000000L);
+ case 123:
+ return jjStartNfaWithStates_8(0, 12, 64);
+ case 125:
+ return jjStopAtPos(0, 13);
+ default :
+ return jjMoveNfa_8(3, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_8(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_8(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x2000000L) != 0L)
+ return jjStopAtPos(1, 25);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_8(1, 23, 0);
+ break;
+ case 46:
+ if ((active0 & 0x400L) != 0L)
+ return jjStopAtPos(1, 10);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_8(active0, 0x200000L);
+ case 97:
+ return jjMoveStringLiteralDfa2_8(active0, 0x2000000000L);
+ case 114:
+ return jjMoveStringLiteralDfa2_8(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_8(0, active0);
+}
+private int jjMoveStringLiteralDfa2_8(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_8(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_8(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ case 108:
+ return jjMoveStringLiteralDfa3_8(active0, 0x2000000000L);
+ case 117:
+ return jjMoveStringLiteralDfa3_8(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_8(1, active0);
+}
+private int jjMoveStringLiteralDfa3_8(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_8(1, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_8(2, active0);
+ return 3;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x1000000000L) != 0L)
+ return jjStartNfaWithStates_8(3, 36, 62);
+ break;
+ case 115:
+ return jjMoveStringLiteralDfa4_8(active0, 0x2000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_8(2, active0);
+}
+private int jjMoveStringLiteralDfa4_8(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_8(2, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_8(3, active0);
+ return 4;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x2000000000L) != 0L)
+ return jjStartNfaWithStates_8(4, 37, 62);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_8(3, active0);
+}
+private int jjStartNfaWithStates_8(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_8(state, pos + 1);
+}
+private int jjMoveNfa_8(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 100;
+ 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 3:
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddStates(117, 122);
+ }
+ else if ((0x2400L & l) != 0L)
+ {
+ if (kind > 33)
+ kind = 33;
+ }
+ else if ((0x100000200L & l) != 0L)
+ {
+ if (kind > 32)
+ kind = 32;
+ jjCheckNAdd(4);
+ }
+ else if (curChar == 45)
+ jjCheckNAddStates(123, 126);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(72, 73);
+ }
+ else if (curChar == 46)
+ jjCheckNAdd(57);
+ else if (curChar == 33)
+ {
+ if (kind > 51)
+ kind = 51;
+ }
+ else if (curChar == 61)
+ jjstateSet[jjnewStateCnt++] = 49;
+ else if (curChar == 62)
+ jjstateSet[jjnewStateCnt++] = 47;
+ else if (curChar == 60)
+ jjstateSet[jjnewStateCnt++] = 44;
+ else if (curChar == 38)
+ jjstateSet[jjnewStateCnt++] = 34;
+ else if (curChar == 39)
+ jjCheckNAddStates(55, 58);
+ else if (curChar == 34)
+ jjCheckNAddStates(59, 62);
+ else if (curChar == 35)
+ jjstateSet[jjnewStateCnt++] = 2;
+ if (curChar == 33)
+ jjstateSet[jjnewStateCnt++] = 53;
+ else if (curChar == 62)
+ {
+ if (kind > 47)
+ kind = 47;
+ }
+ else if (curChar == 60)
+ {
+ if (kind > 45)
+ kind = 45;
+ }
+ else if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 100:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(95, 96);
+ else if (curChar == 46)
+ jjCheckNAdd(57);
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(89, 90);
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddTwoStates(86, 88);
+ }
+ break;
+ case 0:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 1:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 2:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 0;
+ break;
+ case 4:
+ if ((0x100000200L & l) == 0L)
+ break;
+ if (kind > 32)
+ kind = 32;
+ jjCheckNAdd(4);
+ break;
+ case 5:
+ if ((0x2400L & l) != 0L && kind > 33)
+ kind = 33;
+ break;
+ case 6:
+ if (curChar == 10 && kind > 33)
+ kind = 33;
+ break;
+ case 7:
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 8:
+ case 10:
+ if (curChar == 34)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 9:
+ if ((0xfffffffbefffffffL & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 11:
+ if (curChar == 34)
+ jjstateSet[jjnewStateCnt++] = 10;
+ break;
+ case 12:
+ if (curChar == 34 && kind > 35)
+ kind = 35;
+ break;
+ case 15:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAddStates(63, 67);
+ break;
+ case 16:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 17:
+ if ((0xf000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 18;
+ break;
+ case 18:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAdd(16);
+ break;
+ case 20:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 21:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 22;
+ break;
+ case 22:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 23;
+ break;
+ case 23:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 24:
+ if (curChar == 32)
+ jjAddStates(68, 69);
+ break;
+ case 25:
+ if (curChar == 10)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 26:
+ case 28:
+ if (curChar == 39)
+ jjCheckNAddStates(55, 58);
+ break;
+ case 27:
+ if ((0xffffff7fefffffffL & l) != 0L)
+ jjCheckNAddStates(55, 58);
+ break;
+ case 29:
+ if (curChar == 39)
+ jjstateSet[jjnewStateCnt++] = 28;
+ break;
+ case 31:
+ if (curChar == 32)
+ jjAddStates(70, 71);
+ break;
+ case 32:
+ if (curChar == 10)
+ jjCheckNAddStates(55, 58);
+ break;
+ case 33:
+ if (curChar == 39 && kind > 35)
+ kind = 35;
+ break;
+ case 34:
+ if (curChar == 38 && kind > 43)
+ kind = 43;
+ break;
+ case 35:
+ if (curChar == 38)
+ jjstateSet[jjnewStateCnt++] = 34;
+ break;
+ case 43:
+ if (curChar == 60 && kind > 45)
+ kind = 45;
+ break;
+ case 44:
+ if (curChar == 61 && kind > 46)
+ kind = 46;
+ break;
+ case 45:
+ if (curChar == 60)
+ jjstateSet[jjnewStateCnt++] = 44;
+ break;
+ case 46:
+ if (curChar == 62 && kind > 47)
+ kind = 47;
+ break;
+ case 47:
+ if (curChar == 61 && kind > 48)
+ kind = 48;
+ break;
+ case 48:
+ if (curChar == 62)
+ jjstateSet[jjnewStateCnt++] = 47;
+ break;
+ case 49:
+ if (curChar == 61 && kind > 49)
+ kind = 49;
+ break;
+ case 50:
+ if (curChar == 61)
+ jjstateSet[jjnewStateCnt++] = 49;
+ break;
+ case 53:
+ if (curChar == 61 && kind > 50)
+ kind = 50;
+ break;
+ case 54:
+ if (curChar == 33)
+ jjstateSet[jjnewStateCnt++] = 53;
+ break;
+ case 55:
+ if (curChar == 33 && kind > 51)
+ kind = 51;
+ break;
+ case 56:
+ if (curChar == 46)
+ jjCheckNAdd(57);
+ break;
+ case 57:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(57, 58);
+ break;
+ case 59:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(60);
+ break;
+ case 60:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(60);
+ break;
+ case 62:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 63)
+ kind = 63;
+ jjstateSet[jjnewStateCnt++] = 62;
+ break;
+ case 65:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjAddStates(127, 128);
+ break;
+ case 69:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 71:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(72, 73);
+ break;
+ case 73:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 74:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(72, 73);
+ break;
+ case 85:
+ if (curChar == 45)
+ jjCheckNAddStates(123, 126);
+ break;
+ case 86:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddTwoStates(86, 88);
+ break;
+ case 87:
+ if (curChar == 46 && kind > 58)
+ kind = 58;
+ break;
+ case 88:
+ if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 87;
+ break;
+ case 89:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(89, 90);
+ break;
+ case 90:
+ if (curChar != 46)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(91, 92);
+ break;
+ case 91:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(91, 92);
+ break;
+ case 93:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(94);
+ break;
+ case 94:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(94);
+ break;
+ case 95:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(95, 96);
+ break;
+ case 97:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(98);
+ break;
+ case 98:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(98);
+ break;
+ case 99:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddStates(117, 122);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 3:
+ if ((0x7fffffe87ffffffL & l) != 0L)
+ {
+ if (kind > 63)
+ kind = 63;
+ jjCheckNAdd(62);
+ }
+ else if (curChar == 92)
+ jjCheckNAddStates(129, 132);
+ else if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 64;
+ else if (curChar == 124)
+ jjstateSet[jjnewStateCnt++] = 39;
+ if (curChar == 110)
+ jjAddStates(133, 134);
+ else if (curChar == 103)
+ jjAddStates(135, 136);
+ else if (curChar == 108)
+ jjAddStates(137, 138);
+ else if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 51;
+ else if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 41;
+ else if (curChar == 97)
+ jjstateSet[jjnewStateCnt++] = 37;
+ break;
+ case 1:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 9:
+ jjCheckNAddStates(59, 62);
+ break;
+ case 13:
+ if (curChar == 92)
+ jjAddStates(82, 87);
+ break;
+ case 14:
+ if ((0x14404400000000L & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 19:
+ if (curChar == 117)
+ jjstateSet[jjnewStateCnt++] = 20;
+ break;
+ case 20:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 21:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 22;
+ break;
+ case 22:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 23;
+ break;
+ case 23:
+ if ((0x7e0000007eL & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 27:
+ jjAddStates(55, 58);
+ break;
+ case 30:
+ if (curChar == 92)
+ jjAddStates(70, 71);
+ break;
+ case 36:
+ if (curChar == 100 && kind > 43)
+ kind = 43;
+ break;
+ case 37:
+ if (curChar == 110)
+ jjstateSet[jjnewStateCnt++] = 36;
+ break;
+ case 38:
+ if (curChar == 97)
+ jjstateSet[jjnewStateCnt++] = 37;
+ break;
+ case 39:
+ if (curChar == 124 && kind > 44)
+ kind = 44;
+ break;
+ case 40:
+ if (curChar == 124)
+ jjstateSet[jjnewStateCnt++] = 39;
+ break;
+ case 41:
+ if (curChar == 114 && kind > 44)
+ kind = 44;
+ break;
+ case 42:
+ if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 41;
+ break;
+ case 51:
+ if (curChar == 113 && kind > 49)
+ kind = 49;
+ break;
+ case 52:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 51;
+ break;
+ case 58:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(88, 89);
+ break;
+ case 61:
+ if ((0x7fffffe87ffffffL & l) == 0L)
+ break;
+ if (kind > 63)
+ kind = 63;
+ jjCheckNAdd(62);
+ break;
+ case 62:
+ if ((0x7fffffe87fffffeL & l) == 0L)
+ break;
+ if (kind > 63)
+ kind = 63;
+ jjCheckNAdd(62);
+ break;
+ case 63:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 64;
+ break;
+ case 64:
+ if ((0x7fffffe87ffffffL & l) != 0L)
+ jjCheckNAddTwoStates(65, 66);
+ break;
+ case 65:
+ if ((0x7fffffe87fffffeL & l) != 0L)
+ jjCheckNAddTwoStates(65, 66);
+ break;
+ case 66:
+ if (curChar == 125 && kind > 64)
+ kind = 64;
+ break;
+ case 67:
+ if (curChar == 92)
+ jjCheckNAddStates(129, 132);
+ break;
+ case 68:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(68, 69);
+ break;
+ case 70:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(70, 71);
+ break;
+ case 72:
+ if (curChar == 92)
+ jjAddStates(43, 44);
+ break;
+ case 75:
+ if (curChar == 108)
+ jjAddStates(137, 138);
+ break;
+ case 76:
+ if (curChar == 116 && kind > 45)
+ kind = 45;
+ break;
+ case 77:
+ if (curChar == 101 && kind > 46)
+ kind = 46;
+ break;
+ case 78:
+ if (curChar == 103)
+ jjAddStates(135, 136);
+ break;
+ case 79:
+ if (curChar == 116 && kind > 47)
+ kind = 47;
+ break;
+ case 80:
+ if (curChar == 101 && kind > 48)
+ kind = 48;
+ break;
+ case 81:
+ if (curChar == 110)
+ jjAddStates(133, 134);
+ break;
+ case 82:
+ if (curChar == 101 && kind > 50)
+ kind = 50;
+ break;
+ case 83:
+ if (curChar == 116 && kind > 51)
+ kind = 51;
+ break;
+ case 84:
+ if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 83;
+ break;
+ case 92:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(139, 140);
+ break;
+ case 96:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(141, 142);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ case 9:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(59, 62);
+ break;
+ case 27:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(55, 58);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 100 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_17(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x1a00000L) != 0L)
+ return 2;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 0;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_17(int pos, long active0)
+{
+ return jjMoveNfa_17(jjStopStringLiteralDfa_17(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_17()
+{
+ switch(curChar)
+ {
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_17(0xa00000L);
+ case 42:
+ return jjMoveStringLiteralDfa1_17(0x10000000L);
+ default :
+ return jjMoveNfa_17(3, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_17(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_17(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x10000000L) != 0L)
+ return jjStopAtPos(1, 28);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_17(1, 23, 0);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_17(active0, 0x200000L);
+ default :
+ break;
+ }
+ return jjStartNfa_17(0, active0);
+}
+private int jjMoveStringLiteralDfa2_17(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_17(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_17(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_17(1, active0);
+}
+private int jjStartNfaWithStates_17(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_17(state, pos + 1);
+}
+private int jjMoveNfa_17(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 12;
+ 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 3:
+ if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ }
+ else if (curChar == 35)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 0:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 1:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 2:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 0;
+ break;
+ case 6:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 8:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ case 10:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 11:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 3:
+ if (curChar == 92)
+ jjCheckNAddStates(111, 114);
+ break;
+ case 1:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 5:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(5, 6);
+ break;
+ case 7:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 9:
+ if (curChar == 92)
+ jjAddStates(115, 116);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_7(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x4000000000L) != 0L)
+ return 94;
+ if ((active0 & 0x1a00000L) != 0L)
+ return 2;
+ if ((active0 & 0x10000000000000L) != 0L)
+ return 49;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 0;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_7(int pos, long active0)
+{
+ return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_7()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_7(0xa00000L);
+ case 37:
+ return jjStopAtPos(0, 42);
+ case 42:
+ return jjStopAtPos(0, 40);
+ case 43:
+ return jjStopAtPos(0, 39);
+ case 45:
+ return jjStartNfaWithStates_7(0, 38, 94);
+ case 47:
+ return jjStopAtPos(0, 41);
+ case 61:
+ return jjStartNfaWithStates_7(0, 52, 49);
+ case 93:
+ return jjStopAtPos(0, 6);
+ case 102:
+ return jjMoveStringLiteralDfa1_7(0x2000000000L);
+ case 116:
+ return jjMoveStringLiteralDfa1_7(0x1000000000L);
+ default :
+ return jjMoveNfa_7(3, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_7(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_7(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_7(1, 23, 0);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_7(active0, 0x200000L);
+ case 97:
+ return jjMoveStringLiteralDfa2_7(active0, 0x2000000000L);
+ case 114:
+ return jjMoveStringLiteralDfa2_7(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_7(0, active0);
+}
+private int jjMoveStringLiteralDfa2_7(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_7(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_7(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ case 108:
+ return jjMoveStringLiteralDfa3_7(active0, 0x2000000000L);
+ case 117:
+ return jjMoveStringLiteralDfa3_7(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_7(1, active0);
+}
+private int jjMoveStringLiteralDfa3_7(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_7(1, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_7(2, active0);
+ return 3;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x1000000000L) != 0L)
+ return jjStopAtPos(3, 36);
+ break;
+ case 115:
+ return jjMoveStringLiteralDfa4_7(active0, 0x2000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_7(2, active0);
+}
+private int jjMoveStringLiteralDfa4_7(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_7(2, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_7(3, active0);
+ return 4;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x2000000000L) != 0L)
+ return jjStopAtPos(4, 37);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_7(3, active0);
+}
+private int jjStartNfaWithStates_7(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_7(state, pos + 1);
+}
+private int jjMoveNfa_7(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 94;
+ 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 94:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(89, 90);
+ else if (curChar == 46)
+ jjCheckNAdd(57);
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(83, 84);
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddTwoStates(80, 82);
+ }
+ break;
+ case 3:
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddStates(45, 50);
+ }
+ else if ((0x2400L & l) != 0L)
+ {
+ if (kind > 33)
+ kind = 33;
+ }
+ else if ((0x100000200L & l) != 0L)
+ {
+ if (kind > 32)
+ kind = 32;
+ jjCheckNAdd(4);
+ }
+ else if (curChar == 45)
+ jjCheckNAddStates(51, 54);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(66, 67);
+ }
+ else if (curChar == 46)
+ jjCheckNAdd(57);
+ else if (curChar == 33)
+ {
+ if (kind > 51)
+ kind = 51;
+ }
+ else if (curChar == 61)
+ jjstateSet[jjnewStateCnt++] = 49;
+ else if (curChar == 62)
+ jjstateSet[jjnewStateCnt++] = 47;
+ else if (curChar == 60)
+ jjstateSet[jjnewStateCnt++] = 44;
+ else if (curChar == 38)
+ jjstateSet[jjnewStateCnt++] = 34;
+ else if (curChar == 39)
+ jjCheckNAddStates(55, 58);
+ else if (curChar == 34)
+ jjCheckNAddStates(59, 62);
+ else if (curChar == 35)
+ jjstateSet[jjnewStateCnt++] = 2;
+ if (curChar == 33)
+ jjstateSet[jjnewStateCnt++] = 53;
+ else if (curChar == 62)
+ {
+ if (kind > 47)
+ kind = 47;
+ }
+ else if (curChar == 60)
+ {
+ if (kind > 45)
+ kind = 45;
+ }
+ else if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 0:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 1:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 2:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 0;
+ break;
+ case 4:
+ if ((0x100000200L & l) == 0L)
+ break;
+ if (kind > 32)
+ kind = 32;
+ jjCheckNAdd(4);
+ break;
+ case 5:
+ if ((0x2400L & l) != 0L && kind > 33)
+ kind = 33;
+ break;
+ case 6:
+ if (curChar == 10 && kind > 33)
+ kind = 33;
+ break;
+ case 7:
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 8:
+ case 10:
+ if (curChar == 34)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 9:
+ if ((0xfffffffbefffffffL & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 11:
+ if (curChar == 34)
+ jjstateSet[jjnewStateCnt++] = 10;
+ break;
+ case 12:
+ if (curChar == 34 && kind > 35)
+ kind = 35;
+ break;
+ case 15:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAddStates(63, 67);
+ break;
+ case 16:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 17:
+ if ((0xf000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 18;
+ break;
+ case 18:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAdd(16);
+ break;
+ case 20:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 21:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 22;
+ break;
+ case 22:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 23;
+ break;
+ case 23:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 24:
+ if (curChar == 32)
+ jjAddStates(68, 69);
+ break;
+ case 25:
+ if (curChar == 10)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 26:
+ case 28:
+ if (curChar == 39)
+ jjCheckNAddStates(55, 58);
+ break;
+ case 27:
+ if ((0xffffff7fefffffffL & l) != 0L)
+ jjCheckNAddStates(55, 58);
+ break;
+ case 29:
+ if (curChar == 39)
+ jjstateSet[jjnewStateCnt++] = 28;
+ break;
+ case 31:
+ if (curChar == 32)
+ jjAddStates(70, 71);
+ break;
+ case 32:
+ if (curChar == 10)
+ jjCheckNAddStates(55, 58);
+ break;
+ case 33:
+ if (curChar == 39 && kind > 35)
+ kind = 35;
+ break;
+ case 34:
+ if (curChar == 38 && kind > 43)
+ kind = 43;
+ break;
+ case 35:
+ if (curChar == 38)
+ jjstateSet[jjnewStateCnt++] = 34;
+ break;
+ case 43:
+ if (curChar == 60 && kind > 45)
+ kind = 45;
+ break;
+ case 44:
+ if (curChar == 61 && kind > 46)
+ kind = 46;
+ break;
+ case 45:
+ if (curChar == 60)
+ jjstateSet[jjnewStateCnt++] = 44;
+ break;
+ case 46:
+ if (curChar == 62 && kind > 47)
+ kind = 47;
+ break;
+ case 47:
+ if (curChar == 61 && kind > 48)
+ kind = 48;
+ break;
+ case 48:
+ if (curChar == 62)
+ jjstateSet[jjnewStateCnt++] = 47;
+ break;
+ case 49:
+ if (curChar == 61 && kind > 49)
+ kind = 49;
+ break;
+ case 50:
+ if (curChar == 61)
+ jjstateSet[jjnewStateCnt++] = 49;
+ break;
+ case 53:
+ if (curChar == 61 && kind > 50)
+ kind = 50;
+ break;
+ case 54:
+ if (curChar == 33)
+ jjstateSet[jjnewStateCnt++] = 53;
+ break;
+ case 55:
+ if (curChar == 33 && kind > 51)
+ kind = 51;
+ break;
+ case 56:
+ if (curChar == 46)
+ jjCheckNAdd(57);
+ break;
+ case 57:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(57, 58);
+ break;
+ case 59:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(60);
+ break;
+ case 60:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(60);
+ break;
+ case 63:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 65:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(66, 67);
+ break;
+ case 67:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 68:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(66, 67);
+ break;
+ case 79:
+ if (curChar == 45)
+ jjCheckNAddStates(51, 54);
+ break;
+ case 80:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddTwoStates(80, 82);
+ break;
+ case 81:
+ if (curChar == 46 && kind > 58)
+ kind = 58;
+ break;
+ case 82:
+ if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 81;
+ break;
+ case 83:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(83, 84);
+ break;
+ case 84:
+ if (curChar != 46)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(85, 86);
+ break;
+ case 85:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(85, 86);
+ break;
+ case 87:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(88);
+ break;
+ case 88:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(88);
+ break;
+ case 89:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(89, 90);
+ break;
+ case 91:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(92);
+ break;
+ case 92:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(92);
+ break;
+ case 93:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddStates(45, 50);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 3:
+ if (curChar == 110)
+ jjAddStates(72, 73);
+ else if (curChar == 103)
+ jjAddStates(74, 75);
+ else if (curChar == 108)
+ jjAddStates(76, 77);
+ else if (curChar == 92)
+ jjCheckNAddStates(78, 81);
+ else if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 51;
+ else if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 41;
+ else if (curChar == 124)
+ jjstateSet[jjnewStateCnt++] = 39;
+ else if (curChar == 97)
+ jjstateSet[jjnewStateCnt++] = 37;
+ break;
+ case 1:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 9:
+ jjCheckNAddStates(59, 62);
+ break;
+ case 13:
+ if (curChar == 92)
+ jjAddStates(82, 87);
+ break;
+ case 14:
+ if ((0x14404400000000L & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 19:
+ if (curChar == 117)
+ jjstateSet[jjnewStateCnt++] = 20;
+ break;
+ case 20:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 21:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 22;
+ break;
+ case 22:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 23;
+ break;
+ case 23:
+ if ((0x7e0000007eL & l) != 0L)
+ jjCheckNAddStates(59, 62);
+ break;
+ case 27:
+ jjAddStates(55, 58);
+ break;
+ case 30:
+ if (curChar == 92)
+ jjAddStates(70, 71);
+ break;
+ case 36:
+ if (curChar == 100 && kind > 43)
+ kind = 43;
+ break;
+ case 37:
+ if (curChar == 110)
+ jjstateSet[jjnewStateCnt++] = 36;
+ break;
+ case 38:
+ if (curChar == 97)
+ jjstateSet[jjnewStateCnt++] = 37;
+ break;
+ case 39:
+ if (curChar == 124 && kind > 44)
+ kind = 44;
+ break;
+ case 40:
+ if (curChar == 124)
+ jjstateSet[jjnewStateCnt++] = 39;
+ break;
+ case 41:
+ if (curChar == 114 && kind > 44)
+ kind = 44;
+ break;
+ case 42:
+ if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 41;
+ break;
+ case 51:
+ if (curChar == 113 && kind > 49)
+ kind = 49;
+ break;
+ case 52:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 51;
+ break;
+ case 58:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(88, 89);
+ break;
+ case 61:
+ if (curChar == 92)
+ jjCheckNAddStates(78, 81);
+ break;
+ case 62:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(62, 63);
+ break;
+ case 64:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(64, 65);
+ break;
+ case 66:
+ if (curChar == 92)
+ jjAddStates(90, 91);
+ break;
+ case 69:
+ if (curChar == 108)
+ jjAddStates(76, 77);
+ break;
+ case 70:
+ if (curChar == 116 && kind > 45)
+ kind = 45;
+ break;
+ case 71:
+ if (curChar == 101 && kind > 46)
+ kind = 46;
+ break;
+ case 72:
+ if (curChar == 103)
+ jjAddStates(74, 75);
+ break;
+ case 73:
+ if (curChar == 116 && kind > 47)
+ kind = 47;
+ break;
+ case 74:
+ if (curChar == 101 && kind > 48)
+ kind = 48;
+ break;
+ case 75:
+ if (curChar == 110)
+ jjAddStates(72, 73);
+ break;
+ case 76:
+ if (curChar == 101 && kind > 50)
+ kind = 50;
+ break;
+ case 77:
+ if (curChar == 116 && kind > 51)
+ kind = 51;
+ break;
+ case 78:
+ if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 77;
+ break;
+ case 86:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(92, 93);
+ break;
+ case 90:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(94, 95);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ case 9:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(59, 62);
+ break;
+ case 27:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(55, 58);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 94 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_13(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x1a00000L) != 0L)
+ return 2;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 0;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_13(int pos, long active0)
+{
+ return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_13()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_13(0xa00000L);
+ default :
+ return jjMoveNfa_13(3, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_13(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_13(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_13(1, 23, 0);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_13(active0, 0x200000L);
+ default :
+ break;
+ }
+ return jjStartNfa_13(0, active0);
+}
+private int jjMoveStringLiteralDfa2_13(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_13(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_13(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_13(1, active0);
+}
+private int jjStartNfaWithStates_13(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_13(state, pos + 1);
+}
+private int jjMoveNfa_13(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 12;
+ 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 3:
+ if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ }
+ else if (curChar == 35)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 0:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 1:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 2:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 0;
+ break;
+ case 6:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 8:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ case 10:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 11:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 3:
+ if (curChar == 92)
+ jjCheckNAddStates(111, 114);
+ break;
+ case 1:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 5:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(5, 6);
+ break;
+ case 7:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 9:
+ if (curChar == 92)
+ jjAddStates(115, 116);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_14(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x1a00000L) != 0L)
+ return 2;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 0;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_14(int pos, long active0)
+{
+ return jjMoveNfa_14(jjStopStringLiteralDfa_14(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_14()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_14(0xa00000L);
+ case 42:
+ return jjMoveStringLiteralDfa1_14(0x8000000L);
+ default :
+ return jjMoveNfa_14(3, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_14(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_14(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x8000000L) != 0L)
+ return jjStopAtPos(1, 27);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_14(1, 23, 0);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_14(active0, 0x200000L);
+ default :
+ break;
+ }
+ return jjStartNfa_14(0, active0);
+}
+private int jjMoveStringLiteralDfa2_14(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_14(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_14(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_14(1, active0);
+}
+private int jjStartNfaWithStates_14(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_14(state, pos + 1);
+}
+private int jjMoveNfa_14(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 12;
+ 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 3:
+ if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ }
+ else if (curChar == 35)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 0:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 1:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 2:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 0;
+ break;
+ case 6:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 8:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ case 10:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 11:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 3:
+ if (curChar == 92)
+ jjCheckNAddStates(111, 114);
+ break;
+ case 1:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 5:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(5, 6);
+ break;
+ case 7:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 9:
+ if (curChar == 92)
+ jjAddStates(115, 116);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x3a00000L) != 0L)
+ return 25;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 31;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_2(int pos, long active0, long active1)
+{
+ return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_2()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 1);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_2(0x2a00000L);
+ case 123:
+ return jjStopAtPos(0, 72);
+ case 125:
+ return jjStopAtPos(0, 73);
+ default :
+ return jjMoveNfa_2(4, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_2(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_2(0, active0, 0L);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x2000000L) != 0L)
+ return jjStopAtPos(1, 25);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_2(1, 23, 31);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_2(active0, 0x200000L);
+ default :
+ break;
+ }
+ return jjStartNfa_2(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_2(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_2(0, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_2(1, active0, 0L);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_2(1, active0, 0L);
+}
+private int jjStartNfaWithStates_2(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_2(state, pos + 1);
+}
+private int jjMoveNfa_2(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 34;
+ 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 25:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 31;
+ break;
+ case 4:
+ if ((0x2400L & l) != 0L)
+ {
+ if (kind > 34)
+ kind = 34;
+ }
+ else if ((0x100000200L & l) != 0L)
+ jjCheckNAddStates(143, 145);
+ else if (curChar == 35)
+ jjAddStates(146, 148);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(17, 18);
+ }
+ if (curChar == 36)
+ jjCheckNAddStates(149, 152);
+ else if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 0:
+ if ((0x100000200L & l) != 0L)
+ jjCheckNAddStates(143, 145);
+ break;
+ case 1:
+ if ((0x2400L & l) != 0L && kind > 34)
+ kind = 34;
+ break;
+ case 2:
+ if (curChar == 10 && kind > 34)
+ kind = 34;
+ break;
+ case 3:
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 5:
+ if ((0x3ff200000000000L & l) == 0L)
+ break;
+ if (kind > 70)
+ kind = 70;
+ jjstateSet[jjnewStateCnt++] = 5;
+ break;
+ case 6:
+ if (curChar == 36)
+ jjCheckNAddStates(149, 152);
+ break;
+ case 8:
+ case 9:
+ if (curChar == 33)
+ jjCheckNAdd(7);
+ break;
+ case 11:
+ if (curChar == 46 && kind > 80)
+ kind = 80;
+ break;
+ case 14:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 16:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(17, 18);
+ break;
+ case 18:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 19:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(17, 18);
+ break;
+ case 20:
+ if (curChar == 35)
+ jjAddStates(146, 148);
+ break;
+ case 22:
+ if ((0x100000200L & l) != 0L)
+ jjAddStates(153, 154);
+ break;
+ case 23:
+ if (curChar == 40 && kind > 18)
+ kind = 18;
+ break;
+ case 31:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 32;
+ break;
+ case 32:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 25:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 29;
+ else if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 24;
+ break;
+ case 4:
+ if ((0x7fffffe87fffffeL & l) != 0L)
+ {
+ if (kind > 70)
+ kind = 70;
+ jjCheckNAdd(5);
+ }
+ else if (curChar == 92)
+ jjCheckNAddStates(155, 158);
+ break;
+ case 5:
+ if ((0x7fffffe87fffffeL & l) == 0L)
+ break;
+ if (kind > 70)
+ kind = 70;
+ jjCheckNAdd(5);
+ break;
+ case 7:
+ if (curChar == 91 && kind > 80)
+ kind = 80;
+ break;
+ case 10:
+ if (curChar == 92)
+ jjstateSet[jjnewStateCnt++] = 9;
+ break;
+ case 12:
+ if (curChar == 92)
+ jjCheckNAddStates(155, 158);
+ break;
+ case 13:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(13, 14);
+ break;
+ case 15:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(15, 16);
+ break;
+ case 17:
+ if (curChar == 92)
+ jjAddStates(159, 160);
+ break;
+ case 21:
+ if (curChar == 116)
+ jjCheckNAddTwoStates(22, 23);
+ break;
+ case 24:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 26:
+ if (curChar == 125)
+ jjCheckNAddTwoStates(22, 23);
+ break;
+ case 27:
+ if (curChar == 116)
+ jjstateSet[jjnewStateCnt++] = 26;
+ break;
+ case 28:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 27;
+ break;
+ case 29:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 28;
+ break;
+ case 30:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 29;
+ break;
+ case 32:
+ if (kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 32:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_10(int pos, long active0, long active1)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x3a00000L) != 0L)
+ return 39;
+ if ((active1 & 0x3000L) != 0L)
+ return 18;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 45;
+ if ((active1 & 0x1000L) != 0L)
+ return 51;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_10(int pos, long active0, long active1)
+{
+ return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_10()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_10(0x2a00000L, 0x0L);
+ case 92:
+ jjmatchedKind = 77;
+ return jjMoveStringLiteralDfa1_10(0x0L, 0x1000L);
+ default :
+ return jjMoveNfa_10(1, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_10(long active0, long active1)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_10(0, active0, active1);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x2000000L) != 0L)
+ return jjStopAtPos(1, 25);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_10(1, 23, 45);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_10(active0, 0x200000L, active1, 0L);
+ case 92:
+ if ((active1 & 0x1000L) != 0L)
+ return jjStartNfaWithStates_10(1, 76, 51);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_10(0, active0, active1);
+}
+private int jjMoveStringLiteralDfa2_10(long old0, long active0, long old1, long active1)
+{
+ if (((active0 &= old0) | (active1 &= old1)) == 0L)
+ return jjStartNfa_10(0, old0, old1);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_10(1, active0, 0L);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_10(1, active0, 0L);
+}
+private int jjStartNfaWithStates_10(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_10(state, pos + 1);
+}
+private int jjMoveNfa_10(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 51;
+ 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 39:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 45;
+ break;
+ case 18:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(31, 32);
+ else if (curChar == 35)
+ jjAddStates(161, 162);
+ if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ }
+ break;
+ case 51:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(31, 32);
+ if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ }
+ break;
+ case 1:
+ if ((0xffffffe7efffdbffL & l) != 0L)
+ {
+ if (kind > 79)
+ kind = 79;
+ jjCheckNAddStates(163, 165);
+ }
+ else if ((0x2400L & l) != 0L)
+ {
+ if (kind > 33)
+ kind = 33;
+ }
+ else if (curChar == 35)
+ jjAddStates(166, 168);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(31, 32);
+ }
+ if ((0xffffffe6efffd9ffL & l) != 0L)
+ jjCheckNAddStates(169, 172);
+ else if ((0x100000200L & l) != 0L)
+ {
+ if (kind > 32)
+ kind = 32;
+ jjCheckNAdd(0);
+ }
+ else if (curChar == 36)
+ jjCheckNAddStates(173, 176);
+ else if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 0:
+ if ((0x100000200L & l) == 0L)
+ break;
+ if (kind > 32)
+ kind = 32;
+ jjCheckNAdd(0);
+ break;
+ case 2:
+ if (curChar == 10 && kind > 33)
+ kind = 33;
+ break;
+ case 3:
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 4:
+ if ((0xffffffe6efffd9ffL & l) != 0L)
+ jjCheckNAddStates(169, 172);
+ break;
+ case 5:
+ if ((0xffffffe7efffdbffL & l) != 0L)
+ jjCheckNAddStates(177, 179);
+ break;
+ case 6:
+ if ((0x2400L & l) == 0L)
+ break;
+ if (kind > 78)
+ kind = 78;
+ jjCheckNAddStates(180, 182);
+ break;
+ case 7:
+ if ((0xffffffe7efffdbffL & l) != 0L)
+ jjCheckNAddStates(180, 182);
+ break;
+ case 8:
+ if (curChar != 10)
+ break;
+ if (kind > 78)
+ kind = 78;
+ jjCheckNAddStates(180, 182);
+ break;
+ case 9:
+ case 10:
+ if (curChar == 13)
+ jjCheckNAdd(8);
+ break;
+ case 11:
+ if (curChar == 36)
+ jjCheckNAddStates(173, 176);
+ break;
+ case 13:
+ case 14:
+ if (curChar == 33)
+ jjCheckNAdd(12);
+ break;
+ case 16:
+ if (curChar == 46 && kind > 80)
+ kind = 80;
+ break;
+ case 19:
+ if (curChar == 35)
+ jjAddStates(161, 162);
+ break;
+ case 21:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 17)
+ kind = 17;
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 24:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjAddStates(68, 69);
+ break;
+ case 28:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 30:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(31, 32);
+ break;
+ case 32:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 33:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(31, 32);
+ break;
+ case 34:
+ if (curChar == 35)
+ jjAddStates(166, 168);
+ break;
+ case 36:
+ if ((0x100000200L & l) != 0L)
+ jjAddStates(183, 184);
+ break;
+ case 37:
+ if (curChar == 40 && kind > 18)
+ kind = 18;
+ break;
+ case 45:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 46;
+ break;
+ case 46:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 48:
+ if ((0xffffffe7efffdbffL & l) == 0L)
+ break;
+ if (kind > 79)
+ kind = 79;
+ jjCheckNAddStates(163, 165);
+ break;
+ case 49:
+ if ((0xffffffe7efffdbffL & l) != 0L)
+ jjCheckNAddTwoStates(49, 4);
+ break;
+ case 50:
+ if ((0xffffffe7efffdbffL & l) == 0L)
+ break;
+ if (kind > 79)
+ kind = 79;
+ jjCheckNAdd(50);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 39:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 43;
+ else if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 38;
+ break;
+ case 18:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(29, 30);
+ if (curChar == 92)
+ jjCheckNAddTwoStates(27, 28);
+ if (curChar == 92)
+ jjstateSet[jjnewStateCnt++] = 17;
+ break;
+ case 51:
+ if (curChar == 92)
+ jjAddStates(185, 186);
+ if (curChar == 92)
+ jjCheckNAddTwoStates(29, 30);
+ if (curChar == 92)
+ jjCheckNAddTwoStates(27, 28);
+ break;
+ case 1:
+ if ((0xffffffffefffffffL & l) != 0L)
+ {
+ if (kind > 79)
+ kind = 79;
+ jjCheckNAddStates(163, 165);
+ }
+ else if (curChar == 92)
+ jjCheckNAddStates(187, 190);
+ if ((0xffffffffefffffffL & l) != 0L)
+ jjCheckNAddStates(169, 172);
+ else if (curChar == 92)
+ jjAddStates(185, 186);
+ break;
+ case 4:
+ if ((0xffffffffefffffffL & l) != 0L)
+ jjCheckNAddStates(169, 172);
+ break;
+ case 5:
+ if ((0xffffffffefffffffL & l) != 0L)
+ jjCheckNAddStates(177, 179);
+ break;
+ case 7:
+ if ((0xffffffffefffffffL & l) != 0L)
+ jjCheckNAddStates(180, 182);
+ break;
+ case 12:
+ if (curChar == 91 && kind > 80)
+ kind = 80;
+ break;
+ case 15:
+ if (curChar == 92)
+ jjstateSet[jjnewStateCnt++] = 14;
+ break;
+ case 17:
+ if (curChar == 92)
+ jjAddStates(185, 186);
+ break;
+ case 20:
+ if ((0x7fffffe87ffffffL & l) == 0L)
+ break;
+ if (kind > 17)
+ kind = 17;
+ jjCheckNAdd(21);
+ break;
+ case 21:
+ if ((0x7fffffe87fffffeL & l) == 0L)
+ break;
+ if (kind > 17)
+ kind = 17;
+ jjCheckNAdd(21);
+ break;
+ case 22:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 23;
+ break;
+ case 23:
+ if ((0x7fffffe87ffffffL & l) != 0L)
+ jjCheckNAddTwoStates(24, 25);
+ break;
+ case 24:
+ if ((0x7fffffe87fffffeL & l) != 0L)
+ jjCheckNAddTwoStates(24, 25);
+ break;
+ case 25:
+ if (curChar == 125 && kind > 17)
+ kind = 17;
+ break;
+ case 26:
+ if (curChar == 92)
+ jjCheckNAddStates(187, 190);
+ break;
+ case 27:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(27, 28);
+ break;
+ case 29:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(29, 30);
+ break;
+ case 31:
+ if (curChar == 92)
+ jjAddStates(70, 71);
+ break;
+ case 35:
+ if (curChar == 116)
+ jjCheckNAddTwoStates(36, 37);
+ break;
+ case 38:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 35;
+ break;
+ case 40:
+ if (curChar == 125)
+ jjCheckNAddTwoStates(36, 37);
+ break;
+ case 41:
+ if (curChar == 116)
+ jjstateSet[jjnewStateCnt++] = 40;
+ break;
+ case 42:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 41;
+ break;
+ case 43:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 42;
+ break;
+ case 44:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 43;
+ break;
+ case 46:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 48:
+ if ((0xffffffffefffffffL & l) == 0L)
+ break;
+ if (kind > 79)
+ kind = 79;
+ jjCheckNAddStates(163, 165);
+ break;
+ case 49:
+ if ((0xffffffffefffffffL & l) != 0L)
+ jjCheckNAddTwoStates(49, 4);
+ break;
+ case 50:
+ if ((0xffffffffefffffffL & l) == 0L)
+ break;
+ if (kind > 79)
+ kind = 79;
+ jjCheckNAdd(50);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjCheckNAddStates(169, 172);
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ {
+ if (kind > 79)
+ kind = 79;
+ jjCheckNAddStates(163, 165);
+ }
+ break;
+ case 4:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjCheckNAddStates(169, 172);
+ break;
+ case 5:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjCheckNAddStates(177, 179);
+ break;
+ case 7:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjCheckNAddStates(180, 182);
+ break;
+ case 46:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ case 48:
+ if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
+ break;
+ if (kind > 79)
+ kind = 79;
+ jjCheckNAddStates(163, 165);
+ break;
+ case 49:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjCheckNAddTwoStates(49, 4);
+ break;
+ case 50:
+ if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
+ break;
+ if (kind > 79)
+ kind = 79;
+ jjCheckNAdd(50);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 51 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x3a00000L) != 0L)
+ return 25;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 31;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_1(int pos, long active0, long active1)
+{
+ return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_1()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 1);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_1(0x2a00000L);
+ case 123:
+ return jjStopAtPos(0, 72);
+ case 125:
+ return jjStopAtPos(0, 73);
+ default :
+ return jjMoveNfa_1(4, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_1(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_1(0, active0, 0L);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x2000000L) != 0L)
+ return jjStopAtPos(1, 25);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_1(1, 23, 31);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_1(active0, 0x200000L);
+ default :
+ break;
+ }
+ return jjStartNfa_1(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_1(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_1(0, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_1(1, active0, 0L);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_1(1, active0, 0L);
+}
+private int jjStartNfaWithStates_1(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_1(state, pos + 1);
+}
+private int jjMoveNfa_1(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 34;
+ 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 25:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 31;
+ break;
+ case 4:
+ if ((0x2400L & l) != 0L)
+ {
+ if (kind > 34)
+ kind = 34;
+ }
+ else if ((0x100000200L & l) != 0L)
+ jjCheckNAddStates(143, 145);
+ else if (curChar == 35)
+ jjAddStates(146, 148);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(17, 18);
+ }
+ if (curChar == 36)
+ jjCheckNAddStates(149, 152);
+ else if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 0:
+ if ((0x100000200L & l) != 0L)
+ jjCheckNAddStates(143, 145);
+ break;
+ case 1:
+ if ((0x2400L & l) != 0L && kind > 34)
+ kind = 34;
+ break;
+ case 2:
+ if (curChar == 10 && kind > 34)
+ kind = 34;
+ break;
+ case 3:
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 5:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 67)
+ kind = 67;
+ jjstateSet[jjnewStateCnt++] = 5;
+ break;
+ case 6:
+ if (curChar == 36)
+ jjCheckNAddStates(149, 152);
+ break;
+ case 8:
+ case 9:
+ if (curChar == 33)
+ jjCheckNAdd(7);
+ break;
+ case 11:
+ if (curChar == 46 && kind > 80)
+ kind = 80;
+ break;
+ case 14:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 16:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(17, 18);
+ break;
+ case 18:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 19:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(17, 18);
+ break;
+ case 20:
+ if (curChar == 35)
+ jjAddStates(146, 148);
+ break;
+ case 22:
+ if ((0x100000200L & l) != 0L)
+ jjAddStates(153, 154);
+ break;
+ case 23:
+ if (curChar == 40 && kind > 18)
+ kind = 18;
+ break;
+ case 31:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 32;
+ break;
+ case 32:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 25:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 29;
+ else if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 24;
+ break;
+ case 4:
+ if ((0x7fffffe87fffffeL & l) != 0L)
+ {
+ if (kind > 67)
+ kind = 67;
+ jjCheckNAdd(5);
+ }
+ else if (curChar == 92)
+ jjCheckNAddStates(155, 158);
+ break;
+ case 5:
+ if ((0x7fffffe87fffffeL & l) == 0L)
+ break;
+ if (kind > 67)
+ kind = 67;
+ jjCheckNAdd(5);
+ break;
+ case 7:
+ if (curChar == 91 && kind > 80)
+ kind = 80;
+ break;
+ case 10:
+ if (curChar == 92)
+ jjstateSet[jjnewStateCnt++] = 9;
+ break;
+ case 12:
+ if (curChar == 92)
+ jjCheckNAddStates(155, 158);
+ break;
+ case 13:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(13, 14);
+ break;
+ case 15:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(15, 16);
+ break;
+ case 17:
+ if (curChar == 92)
+ jjAddStates(159, 160);
+ break;
+ case 21:
+ if (curChar == 116)
+ jjCheckNAddTwoStates(22, 23);
+ break;
+ case 24:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 26:
+ if (curChar == 125)
+ jjCheckNAddTwoStates(22, 23);
+ break;
+ case 27:
+ if (curChar == 116)
+ jjstateSet[jjnewStateCnt++] = 26;
+ break;
+ case 28:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 27;
+ break;
+ case 29:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 28;
+ break;
+ case 30:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 29;
+ break;
+ case 32:
+ if (kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 32:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_6(int pos, long active0, long active1)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x3a00000L) != 0L)
+ return 15;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 21;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_6(int pos, long active0, long active1)
+{
+ return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_6()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_6(0x2a00000L);
+ case 91:
+ return jjStopAtPos(0, 3);
+ case 123:
+ return jjStopAtPos(0, 72);
+ case 124:
+ jjmatchedKind = 5;
+ return jjMoveStringLiteralDfa1_6(0x10L);
+ case 125:
+ return jjStopAtPos(0, 73);
+ default :
+ return jjMoveNfa_6(0, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_6(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_6(0, active0, 0L);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x2000000L) != 0L)
+ return jjStopAtPos(1, 25);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_6(1, 23, 21);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_6(active0, 0x200000L);
+ case 124:
+ if ((active0 & 0x10L) != 0L)
+ return jjStopAtPos(1, 4);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_6(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_6(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_6(0, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_6(1, active0, 0L);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_6(1, active0, 0L);
+}
+private int jjStartNfaWithStates_6(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_6(state, pos + 1);
+}
+private int jjMoveNfa_6(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 24;
+ 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 0:
+ if (curChar == 35)
+ jjAddStates(0, 2);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(7, 8);
+ }
+ else if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 15:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 4:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 6:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 8:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 9:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 10:
+ if (curChar == 35)
+ jjAddStates(0, 2);
+ break;
+ case 12:
+ if ((0x100000200L & l) != 0L)
+ jjAddStates(3, 4);
+ break;
+ case 13:
+ if (curChar == 40 && kind > 18)
+ kind = 18;
+ break;
+ case 21:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 22;
+ break;
+ case 22:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 0:
+ if (curChar == 92)
+ jjCheckNAddStates(5, 8);
+ break;
+ case 15:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 19;
+ else if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 14;
+ break;
+ case 1:
+ if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
+ kind = 71;
+ break;
+ case 3:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(3, 4);
+ break;
+ case 5:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(5, 6);
+ break;
+ case 7:
+ if (curChar == 92)
+ jjAddStates(9, 10);
+ break;
+ case 11:
+ if (curChar == 116)
+ jjCheckNAddTwoStates(12, 13);
+ break;
+ case 14:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 11;
+ break;
+ case 16:
+ if (curChar == 125)
+ jjCheckNAddTwoStates(12, 13);
+ break;
+ case 17:
+ if (curChar == 116)
+ jjstateSet[jjnewStateCnt++] = 16;
+ break;
+ case 18:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 17;
+ break;
+ case 19:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 18;
+ break;
+ case 20:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 19;
+ break;
+ case 22:
+ if (kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 22:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 24 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_9(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x4000000000L) != 0L)
+ return 96;
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 67;
+ return 53;
+ }
+ if ((active0 & 0x10000000000000L) != 0L)
+ return 45;
+ if ((active0 & 0x400L) != 0L)
+ return 107;
+ if ((active0 & 0x3a00000L) != 0L)
+ return 67;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 73;
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 67;
+ jjmatchedPos = 1;
+ return 53;
+ }
+ return -1;
+ case 2:
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 67;
+ jjmatchedPos = 2;
+ return 53;
+ }
+ return -1;
+ case 3:
+ if ((active0 & 0x1000000000L) != 0L)
+ return 53;
+ if ((active0 & 0x2000000000L) != 0L)
+ {
+ jjmatchedKind = 67;
+ jjmatchedPos = 3;
+ return 53;
+ }
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_9(int pos, long active0)
+{
+ return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_9()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_9(0x2a00000L);
+ case 37:
+ return jjStopAtPos(0, 42);
+ case 41:
+ return jjStopAtPos(0, 16);
+ case 42:
+ return jjStopAtPos(0, 40);
+ case 43:
+ return jjStopAtPos(0, 39);
+ case 44:
+ return jjStopAtPos(0, 9);
+ case 45:
+ return jjStartNfaWithStates_9(0, 38, 96);
+ case 46:
+ return jjMoveStringLiteralDfa1_9(0x400L);
+ case 47:
+ return jjStopAtPos(0, 41);
+ case 58:
+ return jjStopAtPos(0, 11);
+ case 61:
+ return jjStartNfaWithStates_9(0, 52, 45);
+ case 91:
+ return jjStopAtPos(0, 7);
+ case 93:
+ return jjStopAtPos(0, 8);
+ case 102:
+ return jjMoveStringLiteralDfa1_9(0x2000000000L);
+ case 116:
+ return jjMoveStringLiteralDfa1_9(0x1000000000L);
+ case 123:
+ return jjStopAtPos(0, 12);
+ case 125:
+ return jjStopAtPos(0, 13);
+ default :
+ return jjMoveNfa_9(1, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_9(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_9(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x2000000L) != 0L)
+ return jjStopAtPos(1, 25);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_9(1, 23, 73);
+ break;
+ case 46:
+ if ((active0 & 0x400L) != 0L)
+ return jjStopAtPos(1, 10);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_9(active0, 0x200000L);
+ case 97:
+ return jjMoveStringLiteralDfa2_9(active0, 0x2000000000L);
+ case 114:
+ return jjMoveStringLiteralDfa2_9(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_9(0, active0);
+}
+private int jjMoveStringLiteralDfa2_9(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_9(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_9(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ case 108:
+ return jjMoveStringLiteralDfa3_9(active0, 0x2000000000L);
+ case 117:
+ return jjMoveStringLiteralDfa3_9(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_9(1, active0);
+}
+private int jjMoveStringLiteralDfa3_9(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_9(1, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_9(2, active0);
+ return 3;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x1000000000L) != 0L)
+ return jjStartNfaWithStates_9(3, 36, 53);
+ break;
+ case 115:
+ return jjMoveStringLiteralDfa4_9(active0, 0x2000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_9(2, active0);
+}
+private int jjMoveStringLiteralDfa4_9(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_9(2, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_9(3, active0);
+ return 4;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x2000000000L) != 0L)
+ return jjStartNfaWithStates_9(4, 37, 53);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_9(3, active0);
+}
+private int jjStartNfaWithStates_9(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_9(state, pos + 1);
+}
+private int jjMoveNfa_9(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 108;
+ 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 96:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(101, 102);
+ else if (curChar == 46)
+ jjCheckNAdd(97);
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(90, 91);
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddTwoStates(87, 89);
+ }
+ break;
+ case 1:
+ if ((0x3ff000000000000L & l) != 0L)
+ {
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddStates(191, 196);
+ }
+ else if ((0x2400L & l) != 0L)
+ {
+ if (kind > 33)
+ kind = 33;
+ }
+ else if ((0x100000200L & l) != 0L)
+ {
+ if (kind > 32)
+ kind = 32;
+ jjCheckNAdd(0);
+ }
+ else if (curChar == 46)
+ jjCheckNAddTwoStates(97, 107);
+ else if (curChar == 45)
+ jjCheckNAddStates(197, 200);
+ else if (curChar == 35)
+ jjAddStates(201, 203);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(59, 60);
+ }
+ else if (curChar == 33)
+ {
+ if (kind > 51)
+ kind = 51;
+ }
+ else if (curChar == 61)
+ jjstateSet[jjnewStateCnt++] = 45;
+ else if (curChar == 62)
+ jjstateSet[jjnewStateCnt++] = 43;
+ else if (curChar == 60)
+ jjstateSet[jjnewStateCnt++] = 40;
+ else if (curChar == 38)
+ jjstateSet[jjnewStateCnt++] = 30;
+ else if (curChar == 39)
+ jjCheckNAddStates(204, 207);
+ else if (curChar == 34)
+ jjCheckNAddStates(208, 211);
+ if (curChar == 33)
+ jjstateSet[jjnewStateCnt++] = 49;
+ else if (curChar == 62)
+ {
+ if (kind > 47)
+ kind = 47;
+ }
+ else if (curChar == 60)
+ {
+ if (kind > 45)
+ kind = 45;
+ }
+ else if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 107:
+ case 97:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(97, 98);
+ break;
+ case 67:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 73;
+ break;
+ case 0:
+ if ((0x100000200L & l) == 0L)
+ break;
+ if (kind > 32)
+ kind = 32;
+ jjCheckNAdd(0);
+ break;
+ case 2:
+ if (curChar == 10 && kind > 33)
+ kind = 33;
+ break;
+ case 3:
+ if (curChar == 13)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 4:
+ case 6:
+ if (curChar == 34)
+ jjCheckNAddStates(208, 211);
+ break;
+ case 5:
+ if ((0xfffffffbefffffffL & l) != 0L)
+ jjCheckNAddStates(208, 211);
+ break;
+ case 7:
+ if (curChar == 34)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 8:
+ if (curChar == 34 && kind > 35)
+ kind = 35;
+ break;
+ case 11:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAddStates(212, 216);
+ break;
+ case 12:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAddStates(208, 211);
+ break;
+ case 13:
+ if ((0xf000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 14;
+ break;
+ case 14:
+ if ((0xff000000000000L & l) != 0L)
+ jjCheckNAdd(12);
+ break;
+ case 16:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 17;
+ break;
+ case 17:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 18;
+ break;
+ case 18:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 19;
+ break;
+ case 19:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddStates(208, 211);
+ break;
+ case 20:
+ if (curChar == 32)
+ jjAddStates(217, 218);
+ break;
+ case 21:
+ if (curChar == 10)
+ jjCheckNAddStates(208, 211);
+ break;
+ case 22:
+ case 24:
+ if (curChar == 39)
+ jjCheckNAddStates(204, 207);
+ break;
+ case 23:
+ if ((0xffffff7fefffffffL & l) != 0L)
+ jjCheckNAddStates(204, 207);
+ break;
+ case 25:
+ if (curChar == 39)
+ jjstateSet[jjnewStateCnt++] = 24;
+ break;
+ case 27:
+ if (curChar == 32)
+ jjAddStates(219, 220);
+ break;
+ case 28:
+ if (curChar == 10)
+ jjCheckNAddStates(204, 207);
+ break;
+ case 29:
+ if (curChar == 39 && kind > 35)
+ kind = 35;
+ break;
+ case 30:
+ if (curChar == 38 && kind > 43)
+ kind = 43;
+ break;
+ case 31:
+ if (curChar == 38)
+ jjstateSet[jjnewStateCnt++] = 30;
+ break;
+ case 39:
+ if (curChar == 60 && kind > 45)
+ kind = 45;
+ break;
+ case 40:
+ if (curChar == 61 && kind > 46)
+ kind = 46;
+ break;
+ case 41:
+ if (curChar == 60)
+ jjstateSet[jjnewStateCnt++] = 40;
+ break;
+ case 42:
+ if (curChar == 62 && kind > 47)
+ kind = 47;
+ break;
+ case 43:
+ if (curChar == 61 && kind > 48)
+ kind = 48;
+ break;
+ case 44:
+ if (curChar == 62)
+ jjstateSet[jjnewStateCnt++] = 43;
+ break;
+ case 45:
+ if (curChar == 61 && kind > 49)
+ kind = 49;
+ break;
+ case 46:
+ if (curChar == 61)
+ jjstateSet[jjnewStateCnt++] = 45;
+ break;
+ case 49:
+ if (curChar == 61 && kind > 50)
+ kind = 50;
+ break;
+ case 50:
+ if (curChar == 33)
+ jjstateSet[jjnewStateCnt++] = 49;
+ break;
+ case 51:
+ if (curChar == 33 && kind > 51)
+ kind = 51;
+ break;
+ case 53:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 67)
+ kind = 67;
+ jjstateSet[jjnewStateCnt++] = 53;
+ break;
+ case 56:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 58:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(59, 60);
+ break;
+ case 60:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 61:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(59, 60);
+ break;
+ case 62:
+ if (curChar == 35)
+ jjAddStates(201, 203);
+ break;
+ case 64:
+ if ((0x100000200L & l) != 0L)
+ jjAddStates(221, 222);
+ break;
+ case 65:
+ if (curChar == 40 && kind > 18)
+ kind = 18;
+ break;
+ case 73:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 74;
+ break;
+ case 74:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 86:
+ if (curChar == 45)
+ jjCheckNAddStates(197, 200);
+ break;
+ case 87:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddTwoStates(87, 89);
+ break;
+ case 88:
+ if (curChar == 46 && kind > 58)
+ kind = 58;
+ break;
+ case 89:
+ if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 88;
+ break;
+ case 90:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(90, 91);
+ break;
+ case 91:
+ if (curChar != 46)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(92, 93);
+ break;
+ case 92:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAddTwoStates(92, 93);
+ break;
+ case 94:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(95);
+ break;
+ case 95:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(95);
+ break;
+ case 99:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(100);
+ break;
+ case 100:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(100);
+ break;
+ case 101:
+ if ((0x3ff000000000000L & l) != 0L)
+ jjCheckNAddTwoStates(101, 102);
+ break;
+ case 103:
+ if ((0x280000000000L & l) != 0L)
+ jjCheckNAdd(104);
+ break;
+ case 104:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 59)
+ kind = 59;
+ jjCheckNAdd(104);
+ break;
+ case 105:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 58)
+ kind = 58;
+ jjCheckNAddStates(191, 196);
+ break;
+ case 106:
+ if (curChar == 46)
+ jjCheckNAddTwoStates(97, 107);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 1:
+ if ((0x7fffffe87fffffeL & l) != 0L)
+ {
+ if (kind > 67)
+ kind = 67;
+ jjCheckNAdd(53);
+ }
+ else if (curChar == 92)
+ jjCheckNAddStates(223, 226);
+ else if (curChar == 124)
+ jjstateSet[jjnewStateCnt++] = 35;
+ if (curChar == 110)
+ jjAddStates(227, 228);
+ else if (curChar == 103)
+ jjAddStates(229, 230);
+ else if (curChar == 108)
+ jjAddStates(231, 232);
+ else if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 47;
+ else if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 37;
+ else if (curChar == 97)
+ jjstateSet[jjnewStateCnt++] = 33;
+ break;
+ case 107:
+ if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
+ kind = 71;
+ break;
+ case 67:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 71;
+ else if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 66;
+ break;
+ case 5:
+ jjCheckNAddStates(208, 211);
+ break;
+ case 9:
+ if (curChar == 92)
+ jjAddStates(233, 238);
+ break;
+ case 10:
+ if ((0x14404400000000L & l) != 0L)
+ jjCheckNAddStates(208, 211);
+ break;
+ case 15:
+ if (curChar == 117)
+ jjstateSet[jjnewStateCnt++] = 16;
+ break;
+ case 16:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 17;
+ break;
+ case 17:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 18;
+ break;
+ case 18:
+ if ((0x7e0000007eL & l) != 0L)
+ jjstateSet[jjnewStateCnt++] = 19;
+ break;
+ case 19:
+ if ((0x7e0000007eL & l) != 0L)
+ jjCheckNAddStates(208, 211);
+ break;
+ case 23:
+ jjAddStates(204, 207);
+ break;
+ case 26:
+ if (curChar == 92)
+ jjAddStates(219, 220);
+ break;
+ case 32:
+ if (curChar == 100 && kind > 43)
+ kind = 43;
+ break;
+ case 33:
+ if (curChar == 110)
+ jjstateSet[jjnewStateCnt++] = 32;
+ break;
+ case 34:
+ if (curChar == 97)
+ jjstateSet[jjnewStateCnt++] = 33;
+ break;
+ case 35:
+ if (curChar == 124 && kind > 44)
+ kind = 44;
+ break;
+ case 36:
+ if (curChar == 124)
+ jjstateSet[jjnewStateCnt++] = 35;
+ break;
+ case 37:
+ if (curChar == 114 && kind > 44)
+ kind = 44;
+ break;
+ case 38:
+ if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 37;
+ break;
+ case 47:
+ if (curChar == 113 && kind > 49)
+ kind = 49;
+ break;
+ case 48:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 47;
+ break;
+ case 52:
+ case 53:
+ if ((0x7fffffe87fffffeL & l) == 0L)
+ break;
+ if (kind > 67)
+ kind = 67;
+ jjCheckNAdd(53);
+ break;
+ case 54:
+ if (curChar == 92)
+ jjCheckNAddStates(223, 226);
+ break;
+ case 55:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(55, 56);
+ break;
+ case 57:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(57, 58);
+ break;
+ case 59:
+ if (curChar == 92)
+ jjAddStates(88, 89);
+ break;
+ case 63:
+ if (curChar == 116)
+ jjCheckNAddTwoStates(64, 65);
+ break;
+ case 66:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 63;
+ break;
+ case 68:
+ if (curChar == 125)
+ jjCheckNAddTwoStates(64, 65);
+ break;
+ case 69:
+ if (curChar == 116)
+ jjstateSet[jjnewStateCnt++] = 68;
+ break;
+ case 70:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 69;
+ break;
+ case 71:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 70;
+ break;
+ case 72:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 71;
+ break;
+ case 74:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 76:
+ if (curChar == 108)
+ jjAddStates(231, 232);
+ break;
+ case 77:
+ if (curChar == 116 && kind > 45)
+ kind = 45;
+ break;
+ case 78:
+ if (curChar == 101 && kind > 46)
+ kind = 46;
+ break;
+ case 79:
+ if (curChar == 103)
+ jjAddStates(229, 230);
+ break;
+ case 80:
+ if (curChar == 116 && kind > 47)
+ kind = 47;
+ break;
+ case 81:
+ if (curChar == 101 && kind > 48)
+ kind = 48;
+ break;
+ case 82:
+ if (curChar == 110)
+ jjAddStates(227, 228);
+ break;
+ case 83:
+ if (curChar == 101 && kind > 50)
+ kind = 50;
+ break;
+ case 84:
+ if (curChar == 116 && kind > 51)
+ kind = 51;
+ break;
+ case 85:
+ if (curChar == 111)
+ jjstateSet[jjnewStateCnt++] = 84;
+ break;
+ case 93:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(239, 240);
+ break;
+ case 98:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(241, 242);
+ break;
+ case 102:
+ if ((0x2000000020L & l) != 0L)
+ jjAddStates(243, 244);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 5:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(208, 211);
+ break;
+ case 23:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(204, 207);
+ break;
+ case 74:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 108 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_11(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x1a00000L) != 0L)
+ return 2;
+ return -1;
+ case 1:
+ if ((active0 & 0x800000L) != 0L)
+ return 0;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_11(int pos, long active0)
+{
+ return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_11()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_11(0xa00000L);
+ default :
+ return jjMoveNfa_11(3, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_11(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_11(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_11(1, 23, 0);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_11(active0, 0x200000L);
+ default :
+ break;
+ }
+ return jjStartNfa_11(0, active0);
+}
+private int jjMoveStringLiteralDfa2_11(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_11(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_11(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_11(1, active0);
+}
+private int jjStartNfaWithStates_11(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_11(state, pos + 1);
+}
+private int jjMoveNfa_11(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 12;
+ 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 3:
+ if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ }
+ else if (curChar == 35)
+ jjstateSet[jjnewStateCnt++] = 2;
+ break;
+ case 0:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 1:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ case 2:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 0;
+ break;
+ case 6:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 8:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ case 10:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 11:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 3:
+ if (curChar == 92)
+ jjCheckNAddStates(111, 114);
+ break;
+ case 1:
+ if (kind > 22)
+ kind = 22;
+ break;
+ case 5:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(5, 6);
+ break;
+ case 7:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 9:
+ if (curChar == 92)
+ jjAddStates(115, 116);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+private final int jjStopStringLiteralDfa_4(int pos, long active0, long active1)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 67;
+ return 1;
+ }
+ if ((active0 & 0x3a00000L) != 0L)
+ return 17;
+ return -1;
+ case 1:
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 67;
+ jjmatchedPos = 1;
+ return 1;
+ }
+ if ((active0 & 0x800000L) != 0L)
+ return 23;
+ return -1;
+ case 2:
+ if ((active0 & 0x3000000000L) != 0L)
+ {
+ jjmatchedKind = 67;
+ jjmatchedPos = 2;
+ return 1;
+ }
+ return -1;
+ case 3:
+ if ((active0 & 0x2000000000L) != 0L)
+ {
+ jjmatchedKind = 67;
+ jjmatchedPos = 3;
+ return 1;
+ }
+ if ((active0 & 0x1000000000L) != 0L)
+ return 1;
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_4(int pos, long active0, long active1)
+{
+ return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_4()
+{
+ switch(curChar)
+ {
+ case 28:
+ return jjStopAtPos(0, 2);
+ case 35:
+ jjmatchedKind = 24;
+ return jjMoveStringLiteralDfa1_4(0x2a00000L);
+ case 40:
+ return jjStopAtPos(0, 14);
+ case 91:
+ return jjStopAtPos(0, 3);
+ case 102:
+ return jjMoveStringLiteralDfa1_4(0x2000000000L);
+ case 116:
+ return jjMoveStringLiteralDfa1_4(0x1000000000L);
+ case 123:
+ return jjStopAtPos(0, 72);
+ case 124:
+ jjmatchedKind = 5;
+ return jjMoveStringLiteralDfa1_4(0x10L);
+ case 125:
+ return jjStopAtPos(0, 73);
+ default :
+ return jjMoveNfa_4(0, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_4(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_4(0, active0, 0L);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 35:
+ if ((active0 & 0x2000000L) != 0L)
+ return jjStopAtPos(1, 25);
+ break;
+ case 42:
+ if ((active0 & 0x800000L) != 0L)
+ return jjStartNfaWithStates_4(1, 23, 23);
+ break;
+ case 91:
+ return jjMoveStringLiteralDfa2_4(active0, 0x200000L);
+ case 97:
+ return jjMoveStringLiteralDfa2_4(active0, 0x2000000000L);
+ case 114:
+ return jjMoveStringLiteralDfa2_4(active0, 0x1000000000L);
+ case 124:
+ if ((active0 & 0x10L) != 0L)
+ return jjStopAtPos(1, 4);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_4(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_4(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_4(0, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_4(1, active0, 0L);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 91:
+ if ((active0 & 0x200000L) != 0L)
+ return jjStopAtPos(2, 21);
+ break;
+ case 108:
+ return jjMoveStringLiteralDfa3_4(active0, 0x2000000000L);
+ case 117:
+ return jjMoveStringLiteralDfa3_4(active0, 0x1000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_4(1, active0, 0L);
+}
+private int jjMoveStringLiteralDfa3_4(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_4(1, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_4(2, active0, 0L);
+ return 3;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x1000000000L) != 0L)
+ return jjStartNfaWithStates_4(3, 36, 1);
+ break;
+ case 115:
+ return jjMoveStringLiteralDfa4_4(active0, 0x2000000000L);
+ default :
+ break;
+ }
+ return jjStartNfa_4(2, active0, 0L);
+}
+private int jjMoveStringLiteralDfa4_4(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_4(2, old0, 0L);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_4(3, active0, 0L);
+ return 4;
+ }
+ switch(curChar)
+ {
+ case 101:
+ if ((active0 & 0x2000000000L) != 0L)
+ return jjStartNfaWithStates_4(4, 37, 1);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_4(3, active0, 0L);
+}
+private int jjStartNfaWithStates_4(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_4(state, pos + 1);
+}
+private int jjMoveNfa_4(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 26;
+ 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 0:
+ if (curChar == 35)
+ jjAddStates(106, 108);
+ else if (curChar == 36)
+ {
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ }
+ else if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 3;
+ break;
+ case 17:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 23;
+ break;
+ case 1:
+ if ((0x3ff000000000000L & l) == 0L)
+ break;
+ if (kind > 67)
+ kind = 67;
+ jjstateSet[jjnewStateCnt++] = 1;
+ break;
+ case 2:
+ if (curChar == 46)
+ jjstateSet[jjnewStateCnt++] = 3;
+ break;
+ case 6:
+ if (curChar == 36 && kind > 19)
+ kind = 19;
+ break;
+ case 8:
+ if (curChar == 36)
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ case 10:
+ if (curChar == 33 && kind > 20)
+ kind = 20;
+ break;
+ case 11:
+ if (curChar != 36)
+ break;
+ if (kind > 19)
+ kind = 19;
+ jjCheckNAddTwoStates(9, 10);
+ break;
+ case 12:
+ if (curChar == 35)
+ jjAddStates(106, 108);
+ break;
+ case 14:
+ if ((0x100000200L & l) != 0L)
+ jjAddStates(109, 110);
+ break;
+ case 15:
+ if (curChar == 40 && kind > 18)
+ kind = 18;
+ break;
+ case 23:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 24;
+ break;
+ case 24:
+ if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 0:
+ if ((0x7fffffe87fffffeL & l) != 0L)
+ {
+ if (kind > 67)
+ kind = 67;
+ jjCheckNAdd(1);
+ }
+ else if (curChar == 92)
+ jjCheckNAddStates(111, 114);
+ break;
+ case 17:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 21;
+ else if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 16;
+ break;
+ case 1:
+ if ((0x7fffffe87fffffeL & l) == 0L)
+ break;
+ if (kind > 67)
+ kind = 67;
+ jjCheckNAdd(1);
+ break;
+ case 3:
+ if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
+ kind = 71;
+ break;
+ case 4:
+ if (curChar == 92)
+ jjCheckNAddStates(111, 114);
+ break;
+ case 5:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(5, 6);
+ break;
+ case 7:
+ if (curChar == 92)
+ jjCheckNAddTwoStates(7, 8);
+ break;
+ case 9:
+ if (curChar == 92)
+ jjAddStates(115, 116);
+ break;
+ case 13:
+ if (curChar == 116)
+ jjCheckNAddTwoStates(14, 15);
+ break;
+ case 16:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 13;
+ break;
+ case 18:
+ if (curChar == 125)
+ jjCheckNAddTwoStates(14, 15);
+ break;
+ case 19:
+ if (curChar == 116)
+ jjstateSet[jjnewStateCnt++] = 18;
+ break;
+ case 20:
+ if (curChar == 101)
+ jjstateSet[jjnewStateCnt++] = 19;
+ break;
+ case 21:
+ if (curChar == 115)
+ jjstateSet[jjnewStateCnt++] = 20;
+ break;
+ case 22:
+ if (curChar == 123)
+ jjstateSet[jjnewStateCnt++] = 21;
+ break;
+ case 24:
+ if (kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(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 24:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+ kind = 22;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 26 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+static final int[] jjnextStates = {
+ 15, 20, 23, 12, 13, 3, 4, 5, 6, 7, 8, 61, 63, 64, 65, 70,
+ 71, 4, 5, 7, 61, 64, 10, 70, 19, 20, 44, 47, 54, 59, 22, 23,
+ 24, 25, 31, 36, 39, 13, 14, 26, 27, 68, 69, 72, 73, 80, 82, 83,
+ 84, 89, 90, 80, 83, 56, 89, 27, 29, 30, 33, 9, 11, 12, 13, 9,
+ 16, 11, 12, 13, 24, 25, 31, 32, 76, 78, 73, 74, 70, 71, 62, 63,
+ 64, 65, 14, 15, 17, 19, 24, 25, 59, 60, 66, 67, 87, 88, 91, 92,
+ 6, 7, 8, 9, 10, 11, 8, 9, 10, 11, 17, 22, 25, 14, 15, 5,
+ 6, 7, 8, 9, 10, 86, 88, 89, 90, 95, 96, 86, 89, 56, 95, 65,
+ 66, 68, 69, 70, 71, 82, 84, 79, 80, 76, 77, 93, 94, 97, 98, 0,
+ 1, 3, 25, 30, 33, 7, 8, 10, 11, 22, 23, 13, 14, 15, 16, 17,
+ 18, 20, 22, 49, 4, 50, 39, 44, 47, 4, 5, 6, 10, 12, 13, 15,
+ 16, 5, 6, 10, 7, 6, 9, 36, 37, 18, 19, 27, 28, 29, 30, 87,
+ 89, 90, 91, 101, 102, 87, 90, 96, 101, 67, 72, 75, 23, 25, 26, 29,
+ 5, 7, 8, 9, 5, 12, 7, 8, 9, 20, 21, 27, 28, 64, 65, 55,
+ 56, 57, 58, 83, 85, 80, 81, 77, 78, 10, 11, 13, 15, 20, 21, 94,
+ 95, 99, 100, 103, 104,
+};
+private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
+{
+ switch(hiByte)
+ {
+ case 0:
+ return ((jjbitVec2[i2] & l2) != 0L);
+ default :
+ if ((jjbitVec0[i1] & l1) != 0L)
+ return true;
+ return false;
+ }
+}
+
+/** Token literal values. */
+public static final String[] jjstrLiteralImages = {
+null, null, null, null, null, null, null, null, null, null, null, null, null,
+null, null, null, null, null, null, null, null, null, null, null, null, null, null,
+null, null, null, null, null, null, null, null, null, null, null, null, null, null,
+null, null, null, null, null, null, null, null, null, null, null, null, null, null,
+null, null, null, null, null, null, null, null, null, null, null, null, null, null,
+null, null, null, null, null, null, null, null, null, null, null, null, };
+
+/** Lexer state names. */
+public static final String[] lexStateNames = {
+ "PRE_DIRECTIVE",
+ "PRE_REFERENCE",
+ "PRE_OLD_REFERENCE",
+ "REFERENCE",
+ "REFMODIFIER",
+ "OLD_REFMODIFIER",
+ "REFMOD3",
+ "REFINDEX",
+ "DIRECTIVE",
+ "REFMOD2",
+ "DEFAULT",
+ "REFMOD",
+ "IN_TEXTBLOCK",
+ "IN_MULTILINE_COMMENT",
+ "IN_FORMAL_COMMENT",
+ "IN_SINGLE_LINE_COMMENT",
+ "ALT_VAL",
+ "IN_MULTI_LINE_COMMENT",
+};
+
+/** Lex State array. */
+public static final int[] jjnewLexState = {
+ -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 = {
+ 0x8dffffff3e07ffffL, 0x1f3c9L,
+};
+static final long[] jjtoSkip = {
+ 0x40000000L, 0xc00L,
+};
+static final long[] jjtoSpecial = {
+ 0x0L, 0xc00L,
+};
+static final long[] jjtoMore = {
+ 0x81f80000L, 0x0L,
+};
+protected CharStream input_stream;
+private final int[] jjrounds = new int[108];
+private final int[] jjstateSet = new int[216];
+private final StringBuilder jjimage = new StringBuilder();
+private StringBuilder image = jjimage;
+private int jjimageLen;
+private int lengthOfMatch;
+protected char curChar;
+
+/** Constructor with parser. */
+public StandardParserTokenManager(StandardParser parserArg, CharStream stream){
+ parser = parserArg;
+ input_stream = stream;
+}
+
+/** Constructor with parser. */
+public StandardParserTokenManager(StandardParser parserArg, CharStream stream, int lexState){
+ this(parserArg, stream);
+ SwitchTo(lexState);
+}
+
+/** Reinitialise parser. */
+public void ReInit(CharStream stream)
+{
+ jjmatchedPos = jjnewStateCnt = 0;
+ curLexState = defaultLexState;
+ input_stream = stream;
+ ReInitRounds();
+}
+private void ReInitRounds()
+{
+ int i;
+ jjround = 0x80000001;
+ for (i = 108; i-- > 0;)
+ jjrounds[i] = 0x80000000;
+}
+
+/** Reinitialise parser. */
+public void ReInit(CharStream stream, int lexState)
+{
+ ReInit(stream);
+ SwitchTo(lexState);
+}
+
+/** Switch to specified lex state. */
+public void SwitchTo(int lexState)
+{
+ if (lexState >= 18 || lexState < 0)
+ throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
+ else
+ curLexState = lexState;
+}
+
+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, curTokenImage);
+
+ t.beginLine = beginLine;
+ t.endLine = endLine;
+ t.beginColumn = beginColumn;
+ t.endColumn = endColumn;
+
+ return t;
+}
+
+int curLexState = 10;
+int defaultLexState = 10;
+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(java.io.IOException e)
+ {
+ jjmatchedKind = 0;
+ matchedToken = jjFillToken();
+ matchedToken.specialToken = specialToken;
+ return matchedToken;
+ }
+ image = jjimage;
+ image.setLength(0);
+ jjimageLen = 0;
+
+ for (;;)
+ {
+ switch(curLexState)
+ {
+ case 0:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_0();
+ if (jjmatchedPos == 0 && jjmatchedKind > 75)
+ {
+ jjmatchedKind = 75;
+ }
+ break;
+ case 1:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_1();
+ if (jjmatchedPos == 0 && jjmatchedKind > 74)
+ {
+ jjmatchedKind = 74;
+ }
+ break;
+ case 2:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_2();
+ if (jjmatchedPos == 0 && jjmatchedKind > 74)
+ {
+ jjmatchedKind = 74;
+ }
+ break;
+ case 3:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_3();
+ if (jjmatchedPos == 0 && jjmatchedKind > 74)
+ {
+ jjmatchedKind = 74;
+ }
+ break;
+ case 4:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_4();
+ if (jjmatchedPos == 0 && jjmatchedKind > 74)
+ {
+ jjmatchedKind = 74;
+ }
+ break;
+ case 5:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_5();
+ if (jjmatchedPos == 0 && jjmatchedKind > 74)
+ {
+ jjmatchedKind = 74;
+ }
+ break;
+ case 6:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_6();
+ if (jjmatchedPos == 0 && jjmatchedKind > 74)
+ {
+ jjmatchedKind = 74;
+ }
+ break;
+ case 7:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_7();
+ break;
+ case 8:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_8();
+ break;
+ case 9:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_9();
+ break;
+ case 10:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_10();
+ break;
+ case 11:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_11();
+ if (jjmatchedPos == 0 && jjmatchedKind > 74)
+ {
+ jjmatchedKind = 74;
+ }
+ break;
+ case 12:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_12();
+ break;
+ case 13:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_13();
+ break;
+ case 14:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_14();
+ if (jjmatchedPos == 0 && jjmatchedKind > 30)
+ {
+ jjmatchedKind = 30;
+ }
+ break;
+ case 15:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_15();
+ if (jjmatchedPos == 0 && jjmatchedKind > 30)
+ {
+ jjmatchedKind = 30;
+ }
+ break;
+ case 16:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_16();
+ break;
+ case 17:
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_17();
+ if (jjmatchedPos == 0 && jjmatchedKind > 30)
+ {
+ jjmatchedKind = 30;
+ }
+ 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];
+ 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 TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
+ }
+ }
+}
+
+void SkipLexicalActions(Token matchedToken)
+{
+ switch(jjmatchedKind)
+ {
+ case 74 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ /*
+ * push every terminator character back into the stream
+ */
+
+ input_stream.backup(1);
+
+ trace("REF_TERM :");
+
+ stateStackPop();
+ break;
+ case 75 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ trace("DIRECTIVE_TERM :");
+
+ input_stream.backup(1);
+ stateStackPop();
+ break;
+ default :
+ break;
+ }
+}
+void MoreLexicalActions()
+{
+ jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
+ switch(jjmatchedKind)
+ {
+ case 19 :
+ image.append(input_stream.GetSuffix(jjimageLen));
+ jjimageLen = 0;
+ if (! inComment)
+ {
+ /*
+ * if we find ourselves in REFERENCE or PRE_REFERENCE, we need to pop down
+ * to end the previous ref
+ */
+
+ if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE)
+ {
+ stateStackPop();
+ }
+
+ int preReferenceState = parser.hyphenAllowedInIdentifiers ? PRE_OLD_REFERENCE : PRE_REFERENCE;
+
+ trace( " $ : going to " + lexStateNames[preReferenceState]);
+
+ /* do not push PRE states */
+ if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+ {
+ stateStackPush();
+ }
+ switchTo(preReferenceState);
+ }
+ break;
+ case 20 :
+ image.append(input_stream.GetSuffix(jjimageLen));
+ jjimageLen = 0;
+ if (! inComment)
+ {
+ /*
+ * if we find ourselves in REFERENCE or PRE_REFERENCE, we need to pop down
+ * to end the previous ref
+ */
+
+ if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE)
+ {
+ stateStackPop();
+ }
+
+ int preReferenceState = parser.hyphenAllowedInIdentifiers ? PRE_OLD_REFERENCE : PRE_REFERENCE;
+
+ trace( " $ : going to " + lexStateNames[preReferenceState]);
+
+ /* do not push PRE states */
+ if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+ {
+ stateStackPush();
+ }
+ switchTo(preReferenceState);
+ }
+ break;
+ case 21 :
+ image.append(input_stream.GetSuffix(jjimageLen));
+ jjimageLen = 0;
+ if (!inComment)
+ {
+ inComment = true;
+ /* do not push PRE states */
+ if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+ {
+ stateStackPush();
+ }
+ switchTo( IN_TEXTBLOCK );
+ }
+ break;
+ case 22 :
+ image.append(input_stream.GetSuffix(jjimageLen));
+ jjimageLen = 0;
+ if (!inComment)
+ {
+ input_stream.backup(1);
+ inComment = true;
+ /* do not push PRE states */
+ if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+ {
+ stateStackPush();
+ }
+ switchTo( IN_FORMAL_COMMENT);
+ }
+ break;
+ case 23 :
+ image.append(input_stream.GetSuffix(jjimageLen));
+ jjimageLen = 0;
+ if (!inComment)
+ {
+ inComment=true;
+ /* do not push PRE states */
+ if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+ {
+ stateStackPush();
+ }
+ switchTo( IN_MULTI_LINE_COMMENT );
+ }
+ break;
+ case 24 :
+ image.append(input_stream.GetSuffix(jjimageLen));
+ jjimageLen = 0;
+ if (! inComment)
+ {
+ /*
+ * We can have the situation where #if($foo)$foo#end.
+ * We need to transition out of REFERENCE before going to DIRECTIVE.
+ * I don't really like this, but I can't think of a legal way
+ * you are going into DIRECTIVE while in REFERENCE. -gmj
+ */
+
+ if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE || curLexState == REFMODIFIER || curLexState == OLD_REFMODIFIER )
+ {
+ stateStackPop();
+ }
+
+ trace(" # : going to PRE_DIRECTIVE" );
+
+ /* do not push PRE states */
+ if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+ {
+ stateStackPush();
+ }
+ switchTo(PRE_DIRECTIVE);
+ }
+ break;
+ default :
+ break;
+ }
+}
+void TokenLexicalActions(Token matchedToken)
+{
+ switch(jjmatchedKind)
+ {
+ case 1 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ stateStackPop();
+ break;
+ case 3 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ stateStackPush();
+ switchTo(REFINDEX);
+ break;
+ case 4 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ stateStackPop();
+ break;
+ case 5 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ if (curlyLevel == 1)
+ {
+ switchTo(ALT_VAL);
+ }
+ else
+ {
+ stateStackPop();
+ }
+ break;
+ case 6 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ stateStackPop();
+ break;
+ case 12 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ ++curlyLevel;
+ break;
+ case 13 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ --curlyLevel;
+ if (curLexState == ALT_VAL && curlyLevel == 0)
+ {
+ stateStackPop();
+ }
+ break;
+ case 14 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ if (!inComment)
+ lparen++;
+
+ /*
+ * If in REFERENCE and we have seen the dot, then move
+ * to REFMOD2 -> Modifier()
+ */
+
+ if (curLexState == REFMODIFIER || curLexState == OLD_REFMODIFIER )
+ switchTo( REFMOD2 );
+ break;
+ case 15 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ RPARENHandler();
+ break;
+ case 16 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ /*
+ * need to simply switch back to REFERENCE, not drop down the stack
+ * because we can (infinitely) chain, ala
+ * $foo.bar().blargh().woogie().doogie()
+ */
+
+ switchTo( REFMOD3 );
+ break;
+ case 18 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ if (! inComment)
+ {
+ trace(" #set : going to DIRECTIVE" );
+
+ stateStackPush();
+ setInSet(true);
+ switchTo(DIRECTIVE);
+ }
+
+ /*
+ * need the LPAREN action
+ */
+
+ if (!inComment)
+ {
+ lparen++;
+
+ /*
+ * If in REFERENCE and we have seen the dot, then move
+ * to REFMOD2 -> Modifier()
+ */
+
+ if (curLexState == REFMODIFIER || curLexState == OLD_REFMODIFIER )
+ switchTo( REFMOD2 );
+ }
+ break;
+ case 25 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ if (!inComment)
+ {
+ if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE)
+ {
+ stateStackPop();
+ }
+
+ inComment = true;
+ stateStackPush();
+ switchTo(IN_SINGLE_LINE_COMMENT);
+ }
+ break;
+ case 26 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ inComment = false;
+ stateStackPop();
+ if (curLexState == REFERENCE || curLexState == REFMOD3)
+ {
+ // end of reference: pop again
+ stateStackPop();
+ }
+ break;
+ case 27 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ inComment = false;
+ stateStackPop();
+ if (curLexState == REFERENCE || curLexState == REFMOD3)
+ {
+ // end of reference: pop again
+ stateStackPop();
+ }
+ break;
+ case 28 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ inComment = false;
+ stateStackPop();
+ if (curLexState == REFERENCE || curLexState == REFMOD3)
+ {
+ // end of reference: pop again
+ stateStackPop();
+ }
+ break;
+ case 29 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ inComment = false;
+ stateStackPop();
+ break;
+ case 33 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ trace(" NEWLINE :");
+
+ /* if (isInSet()) */
+ setInSet(false);
+ break;
+ case 34 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ stateStackPop();
+ break;
+ case 35 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ /*
+ * - if we are in DIRECTIVE and haven't seen ( yet, then also drop out.
+ * don't forget to account for the beloved yet wierd #set
+ * - finally, if we are in REFMOD2 (remember : $foo.bar( ) then " is ok!
+ */
+
+ if( curLexState == DIRECTIVE && !isInSet() && lparen == 0)
+ stateStackPop();
+ break;
+ case 53 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ stateStackPop();
+ break;
+ case 54 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ switchTo(DIRECTIVE);
+ break;
+ case 55 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ switchTo(DIRECTIVE);
+ break;
+ case 56 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ stateStackPop();
+ break;
+ case 58 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ /*
+ * Remove the double period if it is there
+ */
+ if (matchedToken.image.endsWith("..")) {
+ input_stream.backup(2);
+ matchedToken.image = matchedToken.image.substring(0,matchedToken.image.length()-2);
+ }
+
+ /*
+ * check to see if we are in set
+ * ex. #set($foo = $foo + 3)
+ * because we want to handle the \n after
+ */
+
+ if ( lparen == 0 && !isInSet() && curLexState != REFMOD2 && curLexState != REFINDEX && curLexState != ALT_VAL)
+ {
+ stateStackPop();
+ }
+ break;
+ case 59 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ /*
+ * check to see if we are in set
+ * ex. #set $foo = $foo + 3
+ * because we want to handle the \n after
+ */
+
+ if ( lparen == 0 && !isInSet() && curLexState != REFMOD2 && curLexState != ALT_VAL)
+ {
+ stateStackPop();
+ }
+ break;
+ case 67 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ if (curLexState == PRE_REFERENCE)
+ {
+ switchTo(REFERENCE);
+ }
+ break;
+ case 70 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ if (curLexState == PRE_OLD_REFERENCE)
+ {
+ switchTo(REFERENCE);
+ }
+ break;
+ case 71 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ /*
+ * push the alpha char back into the stream so the following identifier
+ * is complete
+ */
+
+ input_stream.backup(1);
+
+ /*
+ * and munge the <DOT> so we just get a . when we have normal text that
+ * looks like a ref.ident
+ */
+
+ matchedToken.image = ".";
+
+ int refModifierState = parser.hyphenAllowedInIdentifiers ? OLD_REFMODIFIER : REFMODIFIER;
+
+ trace("DOT : switching to " + lexStateNames[refModifierState]);
+ switchTo(refModifierState);
+ break;
+ case 72 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ ++curlyLevel;
+ break;
+ case 73 :
+ image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+ /* maybe it wasn't for our state */
+ while (curlyLevel == 0 && curLexState != DEFAULT)
+ {
+ stateStackPop();
+ }
+ /* At this point, here are all the possible states:
+ * - DEFAULT, which means the '}' is schmoo
+ * - DIRECTIVE or REFMOD2, which means the '}' is a closing map curly
+ * - one of the other REFERENCE states or ALT_VAL, which means the '}' ends the reference
+ * If we're in the last case, pop up state.
+ */
+ if (curLexState != DEFAULT && curLexState != DIRECTIVE && curLexState != REFMOD2)
+ {
+ stateStackPop();
+ }
+ 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);
+}
+
+}
diff --git a/generated-sources/javacc/org/apache/velocity/runtime/parser/Token.java b/generated-sources/javacc/org/apache/velocity/runtime/parser/Token.java
new file mode 100644
index 0000000..066bbbb
--- /dev/null
+++ b/generated-sources/javacc/org/apache/velocity/runtime/parser/Token.java
@@ -0,0 +1,131 @@
+/* Generated By:JavaCC: Do not edit this line. Token.java Version 5.0 */
+/* JavaCCOptions:TOKEN_EXTENDS=,KEEP_LINE_COL=null,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
+package org.apache.velocity.runtime.parser;
+
+/**
+ * Describes the input token stream.
+ */
+
+public class Token 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.
+ */
+ 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=0a7b7b090d8309460a5e68cffc5e2260 (do not edit this line) */
diff --git a/generated-sources/javacc/org/apache/velocity/runtime/parser/TokenMgrError.java b/generated-sources/javacc/org/apache/velocity/runtime/parser/TokenMgrError.java
new file mode 100644
index 0000000..f481292
--- /dev/null
+++ b/generated-sources/javacc/org/apache/velocity/runtime/parser/TokenMgrError.java
@@ -0,0 +1,147 @@
+/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 5.0 */
+/* JavaCCOptions: */
+package org.apache.velocity.runtime.parser;
+
+/** Token Manager Error. */
+public class TokenMgrError extends Error
+{
+
+ /**
+ * 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 0 :
+ continue;
+ 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 LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) {
+ return("Lexical error at line " +
+ errorLine + ", column " +
+ errorColumn + ". Encountered: " +
+ (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)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.
+ */
+ public String getMessage() {
+ return super.getMessage();
+ }
+
+ /*
+ * Constructors of various flavors follow.
+ */
+
+ /** No arg constructor. */
+ public TokenMgrError() {
+ }
+
+ /** Constructor with message and reason. */
+ public TokenMgrError(String message, int reason) {
+ super(message);
+ errorCode = reason;
+ }
+
+ /** Full Constructor. */
+ public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) {
+ this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);
+ }
+}
+/* JavaCC - OriginalChecksum=42f02fdec2666762ff549943b174bf6b (do not edit this line) */
diff --git a/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/JJTStandardParserState.java b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/JJTStandardParserState.java
new file mode 100644
index 0000000..eb61e10
--- /dev/null
+++ b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/JJTStandardParserState.java
@@ -0,0 +1,125 @@
+/* Generated By:JavaCC: Do not edit this line. JJTStandardParserState.java Version 5.0 */
+package org.apache.velocity.runtime.parser.node;
+
+import org.apache.velocity.runtime.parser.*;
+
+public class JJTStandardParserState {
+ private java.util.List<Node> nodes;
+ private java.util.List<Integer> marks;
+
+ private int sp; // number of nodes on stack
+ private int mk; // current mark
+ private boolean node_created;
+
+ public JJTStandardParserState() {
+ nodes = new java.util.ArrayList<Node>();
+ marks = new java.util.ArrayList<Integer>();
+ sp = 0;
+ mk = 0;
+ }
+
+ /* Determines whether the current node was actually closed and
+ pushed. This should only be called in the final user action of a
+ node scope. */
+ public boolean nodeCreated() {
+ return node_created;
+ }
+
+ /* Call this to reinitialize the node stack. It is called
+ automatically by the parser's ReInit() method. */
+ public void reset() {
+ nodes.clear();
+ marks.clear();
+ sp = 0;
+ mk = 0;
+ }
+
+ /* Returns the root node of the AST. It only makes sense to call
+ this after a successful parse. */
+ public Node rootNode() {
+ return nodes.get(0);
+ }
+
+ /* Pushes a node on to the stack. */
+ public void pushNode(Node n) {
+ nodes.add(n);
+ ++sp;
+ }
+
+ /* Returns the node on the top of the stack, and remove it from the
+ stack. */
+ public Node popNode() {
+ if (--sp < mk) {
+ mk = marks.remove(marks.size()-1);
+ }
+ return nodes.remove(nodes.size()-1);
+ }
+
+ /* Returns the node currently on the top of the stack. */
+ public Node peekNode() {
+ return nodes.get(nodes.size()-1);
+ }
+
+ /* Returns the number of children on the stack in the current node
+ scope. */
+ public int nodeArity() {
+ return sp - mk;
+ }
+
+
+ public void clearNodeScope(Node n) {
+ while (sp > mk) {
+ popNode();
+ }
+ mk = marks.remove(marks.size()-1);
+ }
+
+
+ public void openNodeScope(Node n) {
+ marks.add(mk);
+ mk = sp;
+ n.jjtOpen();
+ }
+
+
+ /* A definite node is constructed from a specified number of
+ children. That number of nodes are popped from the stack and
+ made the children of the definite node. Then the definite node
+ is pushed on to the stack. */
+ public void closeNodeScope(Node n, int num) {
+ mk = marks.remove(marks.size()-1);
+ while (num-- > 0) {
+ Node c = popNode();
+ c.jjtSetParent(n);
+ n.jjtAddChild(c, num);
+ }
+ n.jjtClose();
+ pushNode(n);
+ node_created = true;
+ }
+
+
+ /* A conditional node is constructed if its condition is true. All
+ the nodes that have been pushed since the node was opened are
+ made children of the conditional node, which is then pushed
+ on to the stack. If the condition is false the node is not
+ constructed and they are left on the stack. */
+ public void closeNodeScope(Node n, boolean condition) {
+ if (condition) {
+ int a = nodeArity();
+ mk = marks.remove(marks.size()-1);
+ while (a-- > 0) {
+ Node c = popNode();
+ c.jjtSetParent(n);
+ n.jjtAddChild(c, a);
+ }
+ n.jjtClose();
+ pushNode(n);
+ node_created = true;
+ } else {
+ mk = marks.remove(marks.size()-1);
+ node_created = false;
+ }
+ }
+}
+/* JavaCC - OriginalChecksum=d34682d17dff0a3b107321d543729d5d (do not edit this line) */
diff --git a/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserTreeConstants.java b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserTreeConstants.java
new file mode 100644
index 0000000..f6cdcb6
--- /dev/null
+++ b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserTreeConstants.java
@@ -0,0 +1,101 @@
+/* Generated By:JavaCC: Do not edit this line. StandardParserTreeConstants.java Version 5.0 */
+package org.apache.velocity.runtime.parser.node;
+
+import org.apache.velocity.runtime.parser.*;
+
+public interface StandardParserTreeConstants
+{
+ public int JJTPROCESS = 0;
+ public int JJTVOID = 1;
+ public int JJTTEXT = 2;
+ public int JJTESCAPEDDIRECTIVE = 3;
+ public int JJTESCAPE = 4;
+ public int JJTCOMMENT = 5;
+ public int JJTTEXTBLOCK = 6;
+ public int JJTFLOATINGPOINTLITERAL = 7;
+ public int JJTINTEGERLITERAL = 8;
+ public int JJTSTRINGLITERAL = 9;
+ public int JJTIDENTIFIER = 10;
+ public int JJTWORD = 11;
+ public int JJTDIRECTIVEASSIGN = 12;
+ public int JJTDIRECTIVE = 13;
+ public int JJTBLOCK = 14;
+ public int JJTMAP = 15;
+ public int JJTOBJECTARRAY = 16;
+ public int JJTINTEGERRANGE = 17;
+ public int JJTMETHOD = 18;
+ public int JJTINDEX = 19;
+ public int JJTREFERENCE = 20;
+ public int JJTTRUE = 21;
+ public int JJTFALSE = 22;
+ public int JJTIFSTATEMENT = 23;
+ public int JJTELSESTATEMENT = 24;
+ public int JJTELSEIFSTATEMENT = 25;
+ public int JJTSETDIRECTIVE = 26;
+ public int JJTEXPRESSION = 27;
+ public int JJTASSIGNMENT = 28;
+ public int JJTORNODE = 29;
+ public int JJTANDNODE = 30;
+ public int JJTEQNODE = 31;
+ public int JJTNENODE = 32;
+ public int JJTLTNODE = 33;
+ public int JJTGTNODE = 34;
+ public int JJTLENODE = 35;
+ public int JJTGENODE = 36;
+ public int JJTADDNODE = 37;
+ public int JJTSUBTRACTNODE = 38;
+ public int JJTMULNODE = 39;
+ public int JJTDIVNODE = 40;
+ public int JJTMODNODE = 41;
+ public int JJTNOTNODE = 42;
+ public int JJTNEGATENODE = 43;
+
+
+ public String[] jjtNodeName = {
+ "process",
+ "void",
+ "Text",
+ "EscapedDirective",
+ "Escape",
+ "Comment",
+ "Textblock",
+ "FloatingPointLiteral",
+ "IntegerLiteral",
+ "StringLiteral",
+ "Identifier",
+ "Word",
+ "DirectiveAssign",
+ "Directive",
+ "Block",
+ "Map",
+ "ObjectArray",
+ "IntegerRange",
+ "Method",
+ "Index",
+ "Reference",
+ "True",
+ "False",
+ "IfStatement",
+ "ElseStatement",
+ "ElseIfStatement",
+ "SetDirective",
+ "Expression",
+ "Assignment",
+ "OrNode",
+ "AndNode",
+ "EQNode",
+ "NENode",
+ "LTNode",
+ "GTNode",
+ "LENode",
+ "GENode",
+ "AddNode",
+ "SubtractNode",
+ "MulNode",
+ "DivNode",
+ "ModNode",
+ "NotNode",
+ "NegateNode",
+ };
+}
+/* JavaCC - OriginalChecksum=3cbe37a416c36eb645df00e50cd4ad4d (do not edit this line) */
diff --git a/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserVisitor.java b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserVisitor.java
new file mode 100644
index 0000000..0140ae1
--- /dev/null
+++ b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserVisitor.java
@@ -0,0 +1,53 @@
+/* Generated By:JavaCC: Do not edit this line. StandardParserVisitor.java Version 5.0 */
+package org.apache.velocity.runtime.parser.node;
+
+import org.apache.velocity.runtime.parser.*;
+
+public interface StandardParserVisitor
+{
+ public Object visit(SimpleNode node, Object data);
+ public Object visit(ASTprocess node, Object data);
+ public Object visit(ASTText node, Object data);
+ public Object visit(ASTEscapedDirective node, Object data);
+ public Object visit(ASTEscape node, Object data);
+ public Object visit(ASTComment node, Object data);
+ public Object visit(ASTTextblock node, Object data);
+ public Object visit(ASTFloatingPointLiteral node, Object data);
+ public Object visit(ASTIntegerLiteral node, Object data);
+ public Object visit(ASTStringLiteral node, Object data);
+ public Object visit(ASTIdentifier node, Object data);
+ public Object visit(ASTWord node, Object data);
+ public Object visit(ASTDirectiveAssign node, Object data);
+ public Object visit(ASTDirective node, Object data);
+ public Object visit(ASTBlock node, Object data);
+ public Object visit(ASTMap node, Object data);
+ public Object visit(ASTObjectArray node, Object data);
+ public Object visit(ASTIntegerRange node, Object data);
+ public Object visit(ASTMethod node, Object data);
+ public Object visit(ASTIndex node, Object data);
+ public Object visit(ASTReference node, Object data);
+ public Object visit(ASTTrue node, Object data);
+ public Object visit(ASTFalse node, Object data);
+ public Object visit(ASTIfStatement node, Object data);
+ public Object visit(ASTElseStatement node, Object data);
+ public Object visit(ASTElseIfStatement node, Object data);
+ public Object visit(ASTSetDirective node, Object data);
+ public Object visit(ASTExpression node, Object data);
+ public Object visit(ASTAssignment node, Object data);
+ public Object visit(ASTOrNode node, Object data);
+ public Object visit(ASTAndNode node, Object data);
+ public Object visit(ASTEQNode node, Object data);
+ public Object visit(ASTNENode node, Object data);
+ public Object visit(ASTLTNode node, Object data);
+ public Object visit(ASTGTNode node, Object data);
+ public Object visit(ASTLENode node, Object data);
+ public Object visit(ASTGENode node, Object data);
+ public Object visit(ASTAddNode node, Object data);
+ public Object visit(ASTSubtractNode node, Object data);
+ public Object visit(ASTMulNode node, Object data);
+ public Object visit(ASTDivNode node, Object data);
+ public Object visit(ASTModNode node, Object data);
+ public Object visit(ASTNotNode node, Object data);
+ public Object visit(ASTNegateNode node, Object data);
+}
+/* JavaCC - OriginalChecksum=ca5f161786ac4b6910db90de458469db (do not edit this line) */
