diff options
author | Andrew Vuong <akvuong@google.com> | 2023-02-17 22:21:28 +0000 |
---|---|---|
committer | Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com> | 2023-02-17 22:21:28 +0000 |
commit | 3a93ff26417a5ade1de3c4a642cb70cb7a2d3fc0 (patch) | |
tree | 2ab78e0ae0cda6d3ac8006cd6e0c6be8dc78a873 | |
parent | 2294848027485fb41ba6ff3f7bfd060bf48a23eb (diff) | |
parent | 67603ab6a1bfb8674dbe1fda4115c319287dffed (diff) | |
download | apache-velocity-engine-3a93ff26417a5ade1de3c4a642cb70cb7a2d3fc0.tar.gz |
Add java_library to Android.bp and manually generated_sources. am: f2461dce3a am: 2ccb9641e1 am: 67603ab6a1
Original change: https://android-review.googlesource.com/c/platform/external/apache-velocity-engine/+/2436333
Change-Id: I88475e737be5f844156ee5530e120693bfed8c8e
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
10 files changed, 15080 insertions, 0 deletions
@@ -28,3 +28,38 @@ license { "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 00000000..55d9caca --- /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 00000000..1e857d83 --- /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 00000000..32e97712 --- /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 00000000..82761fef --- /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 00000000..066bbbbd --- /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 00000000..f4812925 --- /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 00000000..eb61e104 --- /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 00000000..f6cdcb65 --- /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 00000000..0140ae18 --- /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) */ |