org.apache.velocity.runtime.parser.Parser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of com.liferay.portal.template.velocity
Show all versions of com.liferay.portal.template.velocity
Liferay Portal Template Velocity
The newest version!
/* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
package org.apache.velocity.runtime.parser;
import java.io.*;
import java.util.*;
import org.apache.velocity.exception.VelocityException;
import org.apache.velocity.runtime.RuntimeServices;
import org.apache.velocity.runtime.parser.node.*;
import org.apache.velocity.runtime.directive.Directive;
import org.apache.velocity.runtime.directive.Macro;
import org.apache.velocity.runtime.directive.MacroParseException;
import org.apache.velocity.util.StringUtils;
/**
* 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 Jason van Zyl
* @author Geir Magnusson Jr.
* @author Henning P. Schmiedehausen
* @version $Id: Parser.java 736127 2009-01-20 21:59:00Z byron $
*/
public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/
protected JJTParserState jjtree = new JJTParserState();/**
* This Hashtable contains a list of all of the dynamic directives.
*/
private Hashtable directives = new Hashtable(0);
/**
* Name of current template we are parsing. Passed to us in parse()
*/
public String currentTemplateName = "";
VelocityCharStream velcharstream = null;
private RuntimeServices rsvc = 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 Parser( RuntimeServices rs)
{
/*
* need to call the CTOR first thing.
*/
this( new VelocityCharStream(
new ByteArrayInputStream("\n".getBytes()), 1, 1 ));
/*
* now setup a VCS for later use
*/
velcharstream = new VelocityCharStream(
new ByteArrayInputStream("\n".getBytes()), 1, 1 );
/*
* and save the RuntimeServices
*/
rsvc = rs;
}
/**
* 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.
*/
public SimpleNode parse( Reader reader, String templateName )
throws ParseException
{
SimpleNode sn = null;
currentTemplateName = templateName;
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
*/
rsvc.getLog().error("Parser Error: " + templateName, mee);
throw mee;
}
catch (ParseException pe)
{
rsvc.getLog().error("Parser Exception: " + templateName, pe);
throw new TemplateParseException (pe.currentToken,
pe.expectedTokenSequences, pe.tokenImage, currentTemplateName);
}
catch (TokenMgrError tme)
{
throw new ParseException("Lexical error: " + tme.toString());
}
catch (Exception e)
{
String msg = "Parser Error: " + templateName;
rsvc.getLog().error(msg, e);
throw new VelocityException(msg, e);
}
currentTemplateName = "";
return sn;
}
/**
* This method sets the directives Hashtable
*/
public void setDirectives(Hashtable directives)
{
this.directives = directives;
}
/**
* This method gets a Directive from the directives Hashtable
*/
public Directive getDirective(String directive)
{
return (Directive) directives.get(directive);
}
/**
* This method finds out of the directive exists in the directives
* Hashtable.
*/
public boolean isDirective(String directive)
{
return directives.containsKey(directive);
}
/**
* Produces a processed output for an escaped control or
* pluggable directive
*/
private String escapedDirective( String strImage )
{
int iLast = strImage.lastIndexOf("\\");
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);
}
/*
* is this a PD or a control directive?
*/
if ( isDirective(dirTag) )
{
bRecognizedDirective = true;
}
else if ( rsvc.isVelocimacro(dirTag, currentTemplateName))
{
bRecognizedDirective = true;
}
else
{
/* order for speed? */
if ( dirTag.equals("if")
|| dirTag.equals("end")
|| dirTag.equals("set")
|| dirTag.equals("else")
|| dirTag.equals("elseif")
|| dirTag.equals("stop")
)
{
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 != '\n' && c != '\r' && c != '\t')
{
return false;
}
}
}
catch (IOException e)
{
}
finally
{
/**
* Backup the stream to the initial state
*/
velcharstream.backup(no);
}
return false;
}
/**
* 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);
try {
label_1:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case LPAREN:
case RPAREN:
case ESCAPE_DIRECTIVE:
case SET_DIRECTIVE:
case SINGLE_LINE_COMMENT_START:
case DOUBLE_ESCAPE:
case ESCAPE:
case TEXT:
case FORMAL_COMMENT:
case MULTI_LINE_COMMENT:
case STRING_LITERAL:
case IF_DIRECTIVE:
case STOP_DIRECTIVE:
case INTEGER_LITERAL:
case FLOATING_POINT_LITERAL:
case WORD:
case BRACKETED_WORD:
case IDENTIFIER:
case DOT:
case LCURLY:
case RCURLY:
;
break;
default:
jj_la1[0] = jj_gen;
break label_1;
}
Statement();
}
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 void Statement() throws ParseException {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case IF_DIRECTIVE:
IfStatement();
break;
case STOP_DIRECTIVE:
StopStatement();
break;
default:
jj_la1[1] = jj_gen;
if (jj_2_1(2)) {
Reference();
} else {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case SINGLE_LINE_COMMENT_START:
case FORMAL_COMMENT:
case MULTI_LINE_COMMENT:
Comment();
break;
case SET_DIRECTIVE:
SetDirective();
break;
case ESCAPE_DIRECTIVE:
EscapedDirective();
break;
case DOUBLE_ESCAPE:
Escape();
break;
case WORD:
case BRACKETED_WORD:
Directive();
break;
case LPAREN:
case RPAREN:
case ESCAPE:
case TEXT:
case STRING_LITERAL:
case INTEGER_LITERAL:
case FLOATING_POINT_LITERAL:
case DOT:
case LCURLY:
case RCURLY:
Text();
break;
default:
jj_la1[2] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
}
/**
* 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 # 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_2(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_DIRECTIVE :
case ELSEIF_DIRECTIVE :
case END :
case STOP_DIRECTIVE :
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 ( isDirective(nTag) )
control = true;
else if ( rsvc.isVelocimacro(nTag, currentTemplateName))
control = true;
jjtn000.val = "";
for( int i = 0; i < count; i++)
jjtn000.val += ( control ? "\\" : "\\\\");
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
}
final public void 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[3] = jj_gen;
;
}
break;
case MULTI_LINE_COMMENT:
jj_consume_token(MULTI_LINE_COMMENT);
break;
case FORMAL_COMMENT:
jj_consume_token(FORMAL_COMMENT);
break;
default:
jj_la1[4] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
} 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 {
jj_consume_token(IDENTIFIER);
} 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 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[5] = jj_gen;
if (jj_2_3(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[6] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
throw new Error("Missing return statement in function");
}
/**
* Supports the Pluggable Directives
* #foo( arg+ )
*/
final public SimpleNode Directive() throws ParseException {
/*@bgen(jjtree) Directive */
ASTDirective jjtn000 = new ASTDirective(this, JJTDIRECTIVE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);Token t = null;
int argType;
int argPos = 0;
Directive d;
int directiveType;
boolean isVM = false;
boolean doItNow = false;
try {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WORD:
t = jj_consume_token(WORD);
break;
case BRACKETED_WORD:
t = jj_consume_token(BRACKETED_WORD);
break;
default:
jj_la1[7] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
String directiveName;
if (t.kind == ParserConstants.BRACKETED_WORD)
{
directiveName = t.image.substring(2, t.image.length() - 1);
}
else
{
directiveName = t.image.substring(1);
}
d = (Directive) directives.get(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"))
{
doItNow = true;
}
/*
* set the directive name from here. No reason for the thing to know
* about parser tokens
*/
jjtn000.setDirectiveName(directiveName);
if ( d == null)
{
/*
* if null, then not a real directive, but maybe a Velocimacro
*/
isVM = rsvc.isVelocimacro(directiveName, currentTemplateName);
/*
* Currently, all VMs are LINE directives
*/
directiveType = Directive.LINE;
}
else
{
directiveType = d.getType();
}
/*
* now, switch us out of PRE_DIRECTIVE
*/
token_source.SwitchTo(DIRECTIVE);
argPos = 0;
if (isLeftParenthesis()) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[8] = jj_gen;
;
}
jj_consume_token(LPAREN);
label_3:
while (true) {
if (jj_2_4(2)) {
;
} else {
break label_3;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[9] = jj_gen;
;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case COMMA:
jj_consume_token(COMMA);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[10] = jj_gen;
;
}
break;
default:
jj_la1[11] = jj_gen;
;
}
argType = DirectiveArg();
if (argType == ParserTreeConstants.JJTWORD)
{
if (doItNow && argPos == 0)
{
/* if #macro and it's the 0th arg, ok */
}
else if (isVM)
{
{if (true) throw new MacroParseException("Invalid arg #"
+ argPos + " in VM " + t.image, currentTemplateName, t);}
}
/* if #foreach and it's the 2nd arg, ok */
else if (d != null && (!directiveName.equals("foreach") || argPos != 1))
{
{if (true) throw new MacroParseException("Invalid arg #"
+ argPos + " in directive " + t.image, currentTemplateName, t);}
}
else
{
/* either schmoo or a late-defined macro,
* VelocimacroProxy will have to check for latter. */
}
}
else
{
if (doItNow && argPos == 0)
{
/* if a VM and it's the 0th arg, not ok */
{if (true) throw new MacroParseException("Invalid first arg"
+ " in #macro() directive - must be a"
+ " word token (no \' or \" surrounding)", currentTemplateName, t);}
}
}
argPos++;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[12] = jj_gen;
;
}
jj_consume_token(RPAREN);
if (directiveType == Directive.LINE)
{
{if (true) return jjtn000;}
}
} else {
if (doItNow) // doItNow is true if the directive is "macro"
{
// VELOCITY-667 We get here if we have a "#macro" construct
// without parenthesis which is a parse error
{if (true) throw new MacroParseException("A macro declaration requires at least a name argument"
, currentTemplateName, t);}
}
/**
* Not a directive
*/
token_source.stateStackPop();
token_source.inDirective = false;
{if (true) return jjtn000;}
}
ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
try {
label_4:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case LPAREN:
case RPAREN:
case ESCAPE_DIRECTIVE:
case SET_DIRECTIVE:
case SINGLE_LINE_COMMENT_START:
case DOUBLE_ESCAPE:
case ESCAPE:
case TEXT:
case FORMAL_COMMENT:
case MULTI_LINE_COMMENT:
case STRING_LITERAL:
case IF_DIRECTIVE:
case STOP_DIRECTIVE:
case INTEGER_LITERAL:
case FLOATING_POINT_LITERAL:
case WORD:
case BRACKETED_WORD:
case IDENTIFIER:
case DOT:
case LCURLY:
case RCURLY:
;
break;
default:
jj_la1[13] = jj_gen;
break label_4;
}
Statement();
}
} 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);
}
}
jj_consume_token(END);
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 (doItNow)
{
Macro.processAndRegister(rsvc, t, jjtn000, currentTemplateName);
}
/*
* VM : end
*/
{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");
}
/**
* 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_5(2)) {
Parameter();
jj_consume_token(COLON);
Parameter();
label_5:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case COMMA:
;
break;
default:
jj_la1[14] = jj_gen;
break label_5;
}
jj_consume_token(COMMA);
Parameter();
jj_consume_token(COLON);
Parameter();
}
} else {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[15] = jj_gen;
;
}
}
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[16] = 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 STRING_LITERAL:
case TRUE:
case FALSE:
case INTEGER_LITERAL:
case FLOATING_POINT_LITERAL:
case IDENTIFIER:
case LCURLY:
Parameter();
label_6:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case COMMA:
;
break;
default:
jj_la1[17] = jj_gen;
break label_6;
}
jj_consume_token(COMMA);
Parameter();
}
break;
default:
jj_la1[18] = 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);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[19] = jj_gen;
;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case IDENTIFIER:
case LCURLY:
Reference();
break;
case INTEGER_LITERAL:
IntegerLiteral();
break;
default:
jj_la1[20] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[21] = jj_gen;
;
}
jj_consume_token(DOUBLEDOT);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[22] = jj_gen;
;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case IDENTIFIER:
case LCURLY:
Reference();
break;
case INTEGER_LITERAL:
IntegerLiteral();
break;
default:
jj_la1[23] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[24] = 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);
}
}
}
/**
* This method has yet to be fully implemented
* but will allow arbitrarily nested method
* calls
*/
final public void Parameter() throws ParseException {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[25] = jj_gen;
;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case STRING_LITERAL:
StringLiteral();
break;
case INTEGER_LITERAL:
IntegerLiteral();
break;
default:
jj_la1[26] = jj_gen;
if (jj_2_6(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 LCURLY:
Reference();
break;
case FLOATING_POINT_LITERAL:
FloatingPointLiteral();
break;
default:
jj_la1[27] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[28] = jj_gen;
;
}
}
/**
* 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 WHITESPACE:
case STRING_LITERAL:
case TRUE:
case FALSE:
case INTEGER_LITERAL:
case FLOATING_POINT_LITERAL:
case IDENTIFIER:
case LCURLY:
Parameter();
label_7:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case COMMA:
;
break;
default:
jj_la1[29] = jj_gen;
break label_7;
}
jj_consume_token(COMMA);
Parameter();
}
break;
default:
jj_la1[30] = 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 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:
jj_consume_token(IDENTIFIER);
label_8:
while (true) {
if (jj_2_7(2)) {
;
} else {
break label_8;
}
jj_consume_token(DOT);
if (jj_2_8(3)) {
Method();
} else {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case IDENTIFIER:
Identifier();
break;
default:
jj_la1[31] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
break;
case LCURLY:
jj_consume_token(LCURLY);
jj_consume_token(IDENTIFIER);
label_9:
while (true) {
if (jj_2_9(2)) {
;
} else {
break label_9;
}
jj_consume_token(DOT);
if (jj_2_10(3)) {
Method();
} else {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case IDENTIFIER:
Identifier();
break;
default:
jj_la1[32] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
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 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.
*/
final public void Text() throws ParseException {
/*@bgen(jjtree) Text */
ASTText jjtn000 = new ASTText(this, JJTTEXT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
try {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case TEXT:
jj_consume_token(TEXT);
break;
case DOT:
jj_consume_token(DOT);
break;
case RPAREN:
jj_consume_token(RPAREN);
break;
case LPAREN:
jj_consume_token(LPAREN);
break;
case INTEGER_LITERAL:
jj_consume_token(INTEGER_LITERAL);
break;
case FLOATING_POINT_LITERAL:
jj_consume_token(FLOATING_POINT_LITERAL);
break;
case STRING_LITERAL:
jj_consume_token(STRING_LITERAL);
break;
case ESCAPE:
jj_consume_token(ESCAPE);
break;
case LCURLY:
jj_consume_token(LCURLY);
break;
case RCURLY:
jj_consume_token(RCURLY);
break;
default:
jj_la1[34] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
}
/* -----------------------------------------------------------------------
*
* Defined Directive Syntax
*
* ----------------------------------------------------------------------*/
final public void IfStatement() throws ParseException {
/*@bgen(jjtree) IfStatement */
ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
try {
jj_consume_token(IF_DIRECTIVE);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[35] = jj_gen;
;
}
jj_consume_token(LPAREN);
Expression();
jj_consume_token(RPAREN);
ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
try {
label_10:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case LPAREN:
case RPAREN:
case ESCAPE_DIRECTIVE:
case SET_DIRECTIVE:
case SINGLE_LINE_COMMENT_START:
case DOUBLE_ESCAPE:
case ESCAPE:
case TEXT:
case FORMAL_COMMENT:
case MULTI_LINE_COMMENT:
case STRING_LITERAL:
case IF_DIRECTIVE:
case STOP_DIRECTIVE:
case INTEGER_LITERAL:
case FLOATING_POINT_LITERAL:
case WORD:
case BRACKETED_WORD:
case IDENTIFIER:
case DOT:
case LCURLY:
case RCURLY:
;
break;
default:
jj_la1[36] = jj_gen;
break label_10;
}
Statement();
}
} 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);
}
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case ELSEIF_DIRECTIVE:
label_11:
while (true) {
ElseIfStatement();
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case ELSEIF_DIRECTIVE:
;
break;
default:
jj_la1[37] = jj_gen;
break label_11;
}
}
break;
default:
jj_la1[38] = jj_gen;
;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case ELSE_DIRECTIVE:
ElseStatement();
break;
default:
jj_la1[39] = jj_gen;
;
}
jj_consume_token(END);
} 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 ElseStatement() throws ParseException {
/*@bgen(jjtree) ElseStatement */
ASTElseStatement jjtn000 = new ASTElseStatement(this, JJTELSESTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
try {
jj_consume_token(ELSE_DIRECTIVE);
ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
try {
label_12:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case LPAREN:
case RPAREN:
case ESCAPE_DIRECTIVE:
case SET_DIRECTIVE:
case SINGLE_LINE_COMMENT_START:
case DOUBLE_ESCAPE:
case ESCAPE:
case TEXT:
case FORMAL_COMMENT:
case MULTI_LINE_COMMENT:
case STRING_LITERAL:
case IF_DIRECTIVE:
case STOP_DIRECTIVE:
case INTEGER_LITERAL:
case FLOATING_POINT_LITERAL:
case WORD:
case BRACKETED_WORD:
case IDENTIFIER:
case DOT:
case LCURLY:
case RCURLY:
;
break;
default:
jj_la1[40] = jj_gen;
break label_12;
}
Statement();
}
} 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);
}
}
} 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 ElseIfStatement() throws ParseException {
/*@bgen(jjtree) ElseIfStatement */
ASTElseIfStatement jjtn000 = new ASTElseIfStatement(this, JJTELSEIFSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
try {
jj_consume_token(ELSEIF_DIRECTIVE);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[41] = jj_gen;
;
}
jj_consume_token(LPAREN);
Expression();
jj_consume_token(RPAREN);
ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
try {
label_13:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case LPAREN:
case RPAREN:
case ESCAPE_DIRECTIVE:
case SET_DIRECTIVE:
case SINGLE_LINE_COMMENT_START:
case DOUBLE_ESCAPE:
case ESCAPE:
case TEXT:
case FORMAL_COMMENT:
case MULTI_LINE_COMMENT:
case STRING_LITERAL:
case IF_DIRECTIVE:
case STOP_DIRECTIVE:
case INTEGER_LITERAL:
case FLOATING_POINT_LITERAL:
case WORD:
case BRACKETED_WORD:
case IDENTIFIER:
case DOT:
case LCURLY:
case RCURLY:
;
break;
default:
jj_la1[42] = jj_gen;
break label_13;
}
Statement();
}
} 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);
}
}
} 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);
}
}
}
/**
* Currently support both types of set :
* #set( expr )
* #set expr
*/
final public void SetDirective() throws ParseException {
/*@bgen(jjtree) SetDirective */
ASTSetDirective jjtn000 = new ASTSetDirective(this, JJTSETDIRECTIVE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
try {
jj_consume_token(SET_DIRECTIVE);
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[43] = jj_gen;
;
}
Reference();
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[44] = jj_gen;
;
}
jj_consume_token(EQUALS);
Expression();
jj_consume_token(RPAREN);
/*
* ensure that inSet is false. Leads to some amusing bugs...
*/
token_source.inSet = false;
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case NEWLINE:
jj_consume_token(NEWLINE);
break;
default:
jj_la1[45] = jj_gen;
;
}
} 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);
}
}
}
/**
* This method corresponds to the #stop
* directive which just simulates and EOF
* so that parsing stops. The #stop directive
* is useful for end-user debugging
* purposes.
*/
final public void StopStatement() throws ParseException {
/*@bgen(jjtree) #Stop( 0) */
ASTStop jjtn000 = new ASTStop(this, JJTSTOP);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
try {
jj_consume_token(STOP_DIRECTIVE);
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, 0);
}
}
}
/* -----------------------------------------------------------------------
*
* 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_14:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case LOGICAL_OR:
;
break;
default:
jj_la1[46] = jj_gen;
break label_14;
}
jj_consume_token(LOGICAL_OR);
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_15:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case LOGICAL_AND:
;
break;
default:
jj_la1[47] = jj_gen;
break label_15;
}
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_16:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case LOGICAL_EQUALS:
case LOGICAL_NOT_EQUALS:
;
break;
default:
jj_la1[48] = jj_gen;
break label_16;
}
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[49] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
final public void RelationalExpression() throws ParseException {
AdditiveExpression();
label_17:
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[50] = jj_gen;
break label_17;
}
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[51] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
final public void AdditiveExpression() throws ParseException {
MultiplicativeExpression();
label_18:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case MINUS:
case PLUS:
;
break;
default:
jj_la1[52] = jj_gen;
break label_18;
}
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[53] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
final public void MultiplicativeExpression() throws ParseException {
UnaryExpression();
label_19:
while (true) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case MULTIPLY:
case DIVIDE:
case MODULUS:
;
break;
default:
jj_la1[54] = jj_gen;
break label_19;
}
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[55] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
final public void UnaryExpression() throws ParseException {
if (jj_2_11(2)) {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[56] = jj_gen;
;
}
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);
}
}
} else {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case LBRACKET:
case LEFT_CURLEY:
case LPAREN:
case WHITESPACE:
case STRING_LITERAL:
case TRUE:
case FALSE:
case INTEGER_LITERAL:
case FLOATING_POINT_LITERAL:
case IDENTIFIER:
case LCURLY:
PrimaryExpression();
break;
default:
jj_la1[57] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
final public void PrimaryExpression() throws ParseException {
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[58] = jj_gen;
;
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case STRING_LITERAL:
StringLiteral();
break;
case IDENTIFIER:
case LCURLY:
Reference();
break;
case INTEGER_LITERAL:
IntegerLiteral();
break;
default:
jj_la1[59] = jj_gen;
if (jj_2_12(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[60] = jj_gen;
jj_consume_token(-1);
throw new ParseException();
}
}
}
switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
case WHITESPACE:
jj_consume_token(WHITESPACE);
break;
default:
jj_la1[61] = jj_gen;
;
}
}
final 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); }
}
final 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); }
}
final 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); }
}
final 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); }
}
final 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); }
}
final 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); }
}
final 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); }
}
final 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); }
}
final 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); }
}
final 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); }
}
final 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); }
}
final 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); }
}
final private boolean jj_3_1() {
if (jj_3R_20()) return true;
return false;
}
final private boolean jj_3R_21() {
if (jj_3R_20()) return true;
return false;
}
final private boolean jj_3R_64() {
if (jj_scan_token(LBRACKET)) return true;
Token xsp;
xsp = jj_scanpos;
if (jj_3R_71()) jj_scanpos = xsp;
if (jj_scan_token(RBRACKET)) return true;
return false;
}
final private boolean jj_3R_70() {
Token xsp;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
return false;
}
final private boolean jj_3_5() {
if (jj_3R_25()) return true;
if (jj_scan_token(COLON)) return true;
if (jj_3R_25()) return true;
Token xsp;
while (true) {
xsp = jj_scanpos;
if (jj_3R_85()) { jj_scanpos = xsp; break; }
}
return false;
}
final private boolean jj_3R_63() {
if (jj_scan_token(LEFT_CURLEY)) return true;
Token xsp;
xsp = jj_scanpos;
if (jj_3_5()) {
jj_scanpos = xsp;
if (jj_3R_70()) return true;
}
xsp = jj_scanpos;
if (jj_scan_token(7)) {
jj_scanpos = xsp;
if (jj_scan_token(65)) return true;
}
return false;
}
final private boolean jj_3R_46() {
if (jj_3R_66()) return true;
return false;
}
final private boolean jj_3R_45() {
if (jj_3R_65()) return true;
return false;
}
final private boolean jj_3_3() {
if (jj_scan_token(LBRACKET)) return true;
Token xsp;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
xsp = jj_scanpos;
if (jj_3R_21()) {
jj_scanpos = xsp;
if (jj_3R_22()) return true;
}
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
if (jj_scan_token(DOUBLEDOT)) return true;
return false;
}
final private boolean jj_3R_44() {
if (jj_3R_64()) return true;
return false;
}
final private boolean jj_3R_43() {
if (jj_3R_63()) return true;
return false;
}
final private boolean jj_3R_42() {
if (jj_3R_62()) return true;
return false;
}
final private boolean jj_3R_41() {
if (jj_3R_61()) return true;
return false;
}
final private boolean jj_3R_40() {
if (jj_3R_36()) return true;
return false;
}
final private boolean jj_3R_39() {
if (jj_3R_60()) return true;
return false;
}
final private boolean jj_3R_38() {
if (jj_3R_59()) return true;
return false;
}
final private boolean jj_3R_23() {
if (jj_scan_token(COMMA)) return true;
Token xsp;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
return false;
}
final private boolean jj_3R_37() {
if (jj_3R_20()) return true;
return false;
}
final private boolean jj_3R_24() {
Token xsp;
xsp = jj_scanpos;
if (jj_3R_37()) {
jj_scanpos = xsp;
if (jj_3R_38()) {
jj_scanpos = xsp;
if (jj_3R_39()) {
jj_scanpos = xsp;
if (jj_3R_40()) {
jj_scanpos = xsp;
if (jj_3R_41()) {
jj_scanpos = xsp;
if (jj_3R_42()) {
jj_scanpos = xsp;
if (jj_3R_43()) {
jj_scanpos = xsp;
if (jj_3R_44()) {
jj_scanpos = xsp;
if (jj_3R_45()) {
jj_scanpos = xsp;
if (jj_3R_46()) return true;
}
}
}
}
}
}
}
}
}
return false;
}
final private boolean jj_3R_59() {
if (jj_scan_token(WORD)) return true;
return false;
}
final private boolean jj_3R_56() {
if (jj_scan_token(IDENTIFIER)) return true;
return false;
}
final private boolean jj_3R_30() {
if (jj_3R_56()) return true;
return false;
}
final private boolean jj_3R_28() {
if (jj_3R_56()) return true;
return false;
}
final private boolean jj_3R_33() {
if (jj_3R_36()) return true;
return false;
}
final private boolean jj_3_4() {
Token xsp;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
xsp = jj_scanpos;
if (jj_3R_23()) jj_scanpos = xsp;
if (jj_3R_24()) return true;
return false;
}
final private boolean jj_3R_60() {
if (jj_scan_token(STRING_LITERAL)) return true;
return false;
}
final private boolean jj_3R_36() {
if (jj_scan_token(INTEGER_LITERAL)) return true;
return false;
}
final private boolean jj_3R_32() {
if (jj_3R_20()) return true;
return false;
}
final private boolean jj_3R_27() {
if (jj_3R_36()) return true;
return false;
}
final private boolean jj_3R_62() {
if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
return false;
}
final private boolean jj_3_10() {
if (jj_3R_29()) return true;
return false;
}
final private boolean jj_3R_82() {
if (jj_scan_token(COMMA)) return true;
if (jj_3R_25()) return true;
return false;
}
final private boolean jj_3_8() {
if (jj_3R_29()) return true;
return false;
}
final private boolean jj_3R_26() {
if (jj_3R_20()) return true;
return false;
}
final private boolean jj_3R_66() {
if (jj_scan_token(FALSE)) return true;
return false;
}
final private boolean jj_3R_65() {
if (jj_scan_token(TRUE)) return true;
return false;
}
final private boolean jj_3_9() {
if (jj_scan_token(DOT)) return true;
Token xsp;
xsp = jj_scanpos;
if (jj_3_10()) {
jj_scanpos = xsp;
if (jj_3R_30()) return true;
}
return false;
}
final private boolean jj_3R_57() {
if (jj_3R_25()) return true;
Token xsp;
while (true) {
xsp = jj_scanpos;
if (jj_3R_82()) { jj_scanpos = xsp; break; }
}
return false;
}
final private boolean jj_3_7() {
if (jj_scan_token(DOT)) return true;
Token xsp;
xsp = jj_scanpos;
if (jj_3_8()) {
jj_scanpos = xsp;
if (jj_3R_28()) return true;
}
return false;
}
final private boolean jj_3R_35() {
if (jj_scan_token(LCURLY)) return true;
if (jj_scan_token(IDENTIFIER)) return true;
Token xsp;
while (true) {
xsp = jj_scanpos;
if (jj_3_9()) { jj_scanpos = xsp; break; }
}
if (jj_scan_token(RCURLY)) return true;
return false;
}
final private boolean jj_3_12() {
if (jj_scan_token(LBRACKET)) return true;
Token xsp;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
xsp = jj_scanpos;
if (jj_3R_32()) {
jj_scanpos = xsp;
if (jj_3R_33()) return true;
}
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
if (jj_scan_token(DOUBLEDOT)) return true;
return false;
}
final private boolean jj_3R_34() {
if (jj_scan_token(IDENTIFIER)) return true;
Token xsp;
while (true) {
xsp = jj_scanpos;
if (jj_3_7()) { jj_scanpos = xsp; break; }
}
return false;
}
final private boolean jj_3R_81() {
if (jj_scan_token(LPAREN)) return true;
return false;
}
final private boolean jj_3R_80() {
if (jj_3R_66()) return true;
return false;
}
final private boolean jj_3R_79() {
if (jj_3R_65()) return true;
return false;
}
final private boolean jj_3R_20() {
Token xsp;
xsp = jj_scanpos;
if (jj_3R_34()) {
jj_scanpos = xsp;
if (jj_3R_35()) return true;
}
return false;
}
final private boolean jj_3R_78() {
if (jj_3R_64()) return true;
return false;
}
final private boolean jj_3R_77() {
if (jj_3R_63()) return true;
return false;
}
final private boolean jj_3R_76() {
if (jj_3R_62()) return true;
return false;
}
final private boolean jj_3R_75() {
if (jj_3R_61()) return true;
return false;
}
final private boolean jj_3R_74() {
if (jj_3R_36()) return true;
return false;
}
final private boolean jj_3R_73() {
if (jj_3R_20()) return true;
return false;
}
final private boolean jj_3_6() {
if (jj_scan_token(LBRACKET)) return true;
Token xsp;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
xsp = jj_scanpos;
if (jj_3R_26()) {
jj_scanpos = xsp;
if (jj_3R_27()) return true;
}
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
if (jj_scan_token(DOUBLEDOT)) return true;
return false;
}
final private boolean jj_3_2() {
if (jj_scan_token(DOUBLE_ESCAPE)) return true;
return false;
}
final private boolean jj_3R_29() {
if (jj_3R_56()) return true;
if (jj_scan_token(LPAREN)) return true;
Token xsp;
xsp = jj_scanpos;
if (jj_3R_57()) jj_scanpos = xsp;
if (jj_scan_token(REFMOD2_RPAREN)) return true;
return false;
}
final private boolean jj_3R_72() {
if (jj_3R_60()) return true;
return false;
}
final private boolean jj_3R_67() {
Token xsp;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
xsp = jj_scanpos;
if (jj_3R_72()) {
jj_scanpos = xsp;
if (jj_3R_73()) {
jj_scanpos = xsp;
if (jj_3R_74()) {
jj_scanpos = xsp;
if (jj_3R_75()) {
jj_scanpos = xsp;
if (jj_3R_76()) {
jj_scanpos = xsp;
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()) return true;
}
}
}
}
}
}
}
}
}
return false;
}
final private boolean jj_3R_55() {
if (jj_3R_62()) return true;
return false;
}
final private boolean jj_3R_54() {
if (jj_3R_20()) return true;
return false;
}
final private boolean jj_3R_53() {
if (jj_3R_66()) return true;
return false;
}
final private boolean jj_3R_52() {
if (jj_3R_65()) return true;
return false;
}
final private boolean jj_3R_31() {
Token xsp;
xsp = jj_scanpos;
if (jj_3_11()) {
jj_scanpos = xsp;
if (jj_3R_58()) return true;
}
return false;
}
final private boolean jj_3_11() {
Token xsp;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
if (jj_scan_token(LOGICAL_NOT)) return true;
if (jj_3R_31()) return true;
return false;
}
final private boolean jj_3R_58() {
if (jj_3R_67()) return true;
return false;
}
final private boolean jj_3R_51() {
if (jj_3R_64()) return true;
return false;
}
final private boolean jj_3R_85() {
if (jj_scan_token(COMMA)) return true;
if (jj_3R_25()) return true;
if (jj_scan_token(COLON)) return true;
if (jj_3R_25()) return true;
return false;
}
final private boolean jj_3R_50() {
if (jj_3R_63()) return true;
return false;
}
final private boolean jj_3R_49() {
if (jj_3R_61()) return true;
return false;
}
final private boolean jj_3R_48() {
if (jj_3R_36()) return true;
return false;
}
final private boolean jj_3R_47() {
if (jj_3R_60()) return true;
return false;
}
final private boolean jj_3R_84() {
if (jj_3R_36()) return true;
return false;
}
final private boolean jj_3R_69() {
if (jj_3R_36()) return true;
return false;
}
final private boolean jj_3R_86() {
if (jj_scan_token(COMMA)) return true;
if (jj_3R_25()) return true;
return false;
}
final private boolean jj_3R_25() {
Token xsp;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
xsp = jj_scanpos;
if (jj_3R_47()) {
jj_scanpos = xsp;
if (jj_3R_48()) {
jj_scanpos = xsp;
if (jj_3R_49()) {
jj_scanpos = xsp;
if (jj_3R_50()) {
jj_scanpos = xsp;
if (jj_3R_51()) {
jj_scanpos = xsp;
if (jj_3R_52()) {
jj_scanpos = xsp;
if (jj_3R_53()) {
jj_scanpos = xsp;
if (jj_3R_54()) {
jj_scanpos = xsp;
if (jj_3R_55()) return true;
}
}
}
}
}
}
}
}
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
return false;
}
final private boolean jj_3R_83() {
if (jj_3R_20()) return true;
return false;
}
final private boolean jj_3R_22() {
if (jj_3R_36()) return true;
return false;
}
final private boolean jj_3R_68() {
if (jj_3R_20()) return true;
return false;
}
final private boolean jj_3R_71() {
if (jj_3R_25()) return true;
Token xsp;
while (true) {
xsp = jj_scanpos;
if (jj_3R_86()) { jj_scanpos = xsp; break; }
}
return false;
}
final private boolean jj_3R_61() {
if (jj_scan_token(LBRACKET)) return true;
Token xsp;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
xsp = jj_scanpos;
if (jj_3R_68()) {
jj_scanpos = xsp;
if (jj_3R_69()) return true;
}
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
if (jj_scan_token(DOUBLEDOT)) return true;
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
xsp = jj_scanpos;
if (jj_3R_83()) {
jj_scanpos = xsp;
if (jj_3R_84()) return true;
}
xsp = jj_scanpos;
if (jj_scan_token(26)) jj_scanpos = xsp;
if (jj_scan_token(RBRACKET)) return true;
return false;
}
public ParserTokenManager token_source;
public Token token, jj_nt;
private int jj_ntk;
private Token jj_scanpos, jj_lastpos;
private int jj_la;
public boolean lookingAhead = false;
private boolean jj_semLA;
private int jj_gen;
final private int[] jj_la1 = new int[62];
static private int[] jj_la1_0;
static private int[] jj_la1_1;
static private int[] jj_la1_2;
static {
jj_la1_0();
jj_la1_1();
jj_la1_2();
}
private static void jj_la1_0() {
jj_la1_0 = new int[] {0x9bc1b00,0x0,0x9bc1b00,0x400000,0x1840000,0x8000000,0x30000042,0x0,0x4000000,0x4000000,0x4000000,0x8,0x4000000,0x9bc1b00,0x8,0x4000000,0x80,0x8,0x3c000042,0x4000000,0x0,0x4000000,0x4000000,0x0,0x4000000,0x4000000,0x8000000,0x30000042,0x4000000,0x8,0x3c000042,0x0,0x0,0x0,0x8300300,0x4000000,0x9bc1b00,0x0,0x0,0x0,0x9bc1b00,0x4000000,0x9bc1b00,0x4000000,0x4000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x80000000,0x0,0x0,0x4000000,0x3c000142,0x4000000,0x8000000,0x30000142,0x4000000,};
}
private static void jj_la1_1() {
jj_la1_1 = new int[] {0xc6348000,0x48000,0x86300000,0x0,0x0,0x42100000,0x200000,0x6000000,0x0,0x0,0x0,0x0,0x0,0xc6348000,0x0,0x0,0x0,0x0,0x40300000,0x0,0x40100000,0x0,0x0,0x40100000,0x0,0x0,0x100000,0x40200000,0x0,0x0,0x40300000,0x40000000,0x40000000,0x40000000,0x80300000,0x0,0xc6348000,0x10000,0x10000,0x20000,0xc6348000,0x0,0xc6348000,0x0,0x0,0x0,0x20,0x10,0xc00,0xc00,0x3c0,0x3c0,0x1,0x1,0xe,0xe,0x0,0x40300000,0x0,0x40100000,0x200000,0x0,};
}
private static void jj_la1_2() {
jj_la1_2 = new int[] {0x3,0x0,0x3,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x2,0x0,0x1,0x0,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x0,0x1,0x3,0x0,0x3,0x0,0x0,0x0,0x3,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x0,0x0,};
}
final private JJCalls[] jj_2_rtns = new JJCalls[12];
private boolean jj_rescan = false;
private int jj_gc = 0;
public Parser(CharStream stream) {
token_source = new ParserTokenManager(stream);
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 62; i++) jj_la1[i] = -1;
for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
}
public void ReInit(CharStream stream) {
token_source.ReInit(stream);
token = new Token();
jj_ntk = -1;
jjtree.reset();
jj_gen = 0;
for (int i = 0; i < 62; i++) jj_la1[i] = -1;
for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
}
public Parser(ParserTokenManager tm) {
token_source = tm;
token = new Token();
jj_ntk = -1;
jj_gen = 0;
for (int i = 0; i < 62; i++) jj_la1[i] = -1;
for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
}
public void ReInit(ParserTokenManager tm) {
token_source = tm;
token = new Token();
jj_ntk = -1;
jjtree.reset();
jj_gen = 0;
for (int i = 0; i < 62; i++) jj_la1[i] = -1;
for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
}
final 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();
final 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;
}
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;
}
final public Token getToken(int index) {
Token t = 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;
}
final 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.Vector jj_expentries = new java.util.Vector();
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];
}
boolean exists = false;
for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
int[] oldentry = (int[])(e.nextElement());
if (oldentry.length == jj_expentry.length) {
exists = true;
for (int i = 0; i < jj_expentry.length; i++) {
if (oldentry[i] != jj_expentry[i]) {
exists = false;
break;
}
}
if (exists) break;
}
}
if (!exists) jj_expentries.addElement(jj_expentry);
if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
}
}
public ParseException generateParseException() {
jj_expentries.removeAllElements();
boolean[] la1tokens = new boolean[68];
for (int i = 0; i < 68; i++) {
la1tokens[i] = false;
}
if (jj_kind >= 0) {
la1tokens[jj_kind] = true;
jj_kind = -1;
}
for (int i = 0; i < 62; i++) {
if (jj_la1[i] == jj_gen) {
for (int j = 0; j < 32; j++) {
if ((jj_la1_0[i] & (1< jj_gen) {
jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
switch (i) {
case 0: jj_3_1(); break;
case 1: jj_3_2(); break;
case 2: jj_3_3(); break;
case 3: jj_3_4(); break;
case 4: jj_3_5(); break;
case 5: jj_3_6(); break;
case 6: jj_3_7(); break;
case 7: jj_3_8(); break;
case 8: jj_3_9(); break;
case 9: jj_3_10(); break;
case 10: jj_3_11(); break;
case 11: jj_3_12(); break;
}
}
p = p.next;
} while (p != null);
}
jj_rescan = false;
}
final 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;
}
}