| /* 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.runtime.Runtime; |
| import org.apache.velocity.runtime.parser.node.*; |
| import org.apache.velocity.runtime.directive.Directive; |
| 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 <a href="mailto:jvanzyl@periapt.com">Jason van Zyl</a> |
| * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a> |
| * @version $Id: Parser.java,v 1.30 2000/11/11 22:47:57 geirm Exp $ |
| */ |
| 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); |
| |
| /** This was added to allow the parser to be associated |
| * with a particular syntax. JavaCC doesn't generate |
| * a constructor without parameters. The normal constructor |
| * takes a single argument which an InputStream. But in |
| * order to make the parser dynamically loadable this |
| * constructor had to be added. This also allows us to |
| * create a single instance of a parser and reuse |
| * it over and over. |
| */ |
| public Parser() |
| { |
| this(new ByteArrayInputStream("\n".getBytes())); |
| } |
| |
| /** This was also added to allow parsers to be dynamically |
| * loadable. |
| * |
| * Taken from the generated constructor in Parser.java. |
| * Just be watchful when you change the grammar because |
| * the generated method changes when the grammar changes |
| * WRT to adding new token types. So you have to |
| * occasionally do some cutting and pasting :-) |
| * |
| * It would be A LOT better it you could subclass grammars |
| * and override particular methods but that's not |
| * possible with JavaCC. I believe that you can do |
| * this with ANTLR though. |
| */ |
| public SimpleNode parse(InputStream stream) throws ParseException |
| { |
| SimpleNode sn = null; |
| try |
| { |
| token_source.clearStateVars(); |
| ReInit(stream); |
| sn = process(); |
| } |
| catch (ParseException pe) |
| { |
| Runtime.error ("Parser Exception: " + StringUtils.stackTrace(pe)); |
| throw new ParseException (pe.currentToken, |
| pe.expectedTokenSequences, pe.tokenImage); |
| } |
| catch (Exception e) |
| { |
| Runtime.error ("Parser Error: " + StringUtils.stackTrace(e)); |
| } |
| return sn; |
| } |
| /** |
| * This method sets the directives Hashtable |
| */ |
| public void setDirectives(Hashtable directives) |
| { |
| this.directives = directives; |
| } |
| |
| /** |
| * This method gets 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) |
| { |
| if (directives.containsKey(directive)) |
| return true; |
| else |
| return false; |
| } |
| |
| /** |
| * 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; |
| |
| /* |
| * is this a PD or a control directive? |
| */ |
| |
| if ( isDirective( strDirective.substring(1))) |
| { |
| bRecognizedDirective = true; |
| } |
| else |
| { |
| /* order for speed? */ |
| |
| if ( strDirective.substring(1).equals("if") |
| || strDirective.substring(1).equals("end") |
| || strDirective.substring(1).equals("set") |
| || strDirective.substring(1).equals("else") |
| || strDirective.substring(1).equals("elseif") |
| || strDirective.substring(1).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 ); |
| } |
| |
| /** |
| * 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 DOUBLE_ESCAPE: |
| case ESCAPE: |
| case TEXT: |
| case SINGLE_LINE_COMMENT: |
| case FORMAL_COMMENT: |
| case MULTI_LINE_COMMENT: |
| case STRING_LITERAL: |
| case IF_DIRECTIVE: |
| case STOP_DIRECTIVE: |
| case NUMBER_LITERAL: |
| case WORD: |
| case IDENTIFIER: |
| case DOT: |
| case LCURLY: |
| ; |
| 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 ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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; |
| case IDENTIFIER: |
| case LCURLY: |
| Reference(); |
| break; |
| case SINGLE_LINE_COMMENT: |
| 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: |
| Directive(); |
| break; |
| case LPAREN: |
| case RPAREN: |
| case ESCAPE: |
| case TEXT: |
| case STRING_LITERAL: |
| case NUMBER_LITERAL: |
| case DOT: |
| Text(); |
| break; |
| default: |
| jj_la1[1] = 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 hav 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 iCount = 0; |
| boolean bControl = false; |
| label_2: |
| while (true) { |
| t = jj_consume_token(DOUBLE_ESCAPE); |
| iCount++; |
| if (jj_2_1(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 : |
| bControl = true; |
| break; |
| } |
| |
| /* |
| * if that failed, lets lookahead to see if we matched a PD |
| */ |
| |
| if ( isDirective( t.next.image.substring(1))) |
| bControl = true; |
| |
| t.image = ""; |
| |
| for( int i = 0; i < iCount; i++) |
| t.image += (bControl ? "\\" : "\\\\"); |
| } 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: |
| jj_consume_token(SINGLE_LINE_COMMENT); |
| break; |
| case MULTI_LINE_COMMENT: |
| jj_consume_token(MULTI_LINE_COMMENT); |
| break; |
| case FORMAL_COMMENT: |
| jj_consume_token(FORMAL_COMMENT); |
| break; |
| default: |
| jj_la1[2] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| } |
| } |
| } |
| |
| final public void NumberLiteral() throws ParseException { |
| /*@bgen(jjtree) NumberLiteral */ |
| ASTNumberLiteral jjtn000 = new ASTNumberLiteral(this, JJTNUMBERLITERAL); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| try { |
| jj_consume_token(NUMBER_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 |
| * @see Directive() |
| */ |
| final public void DirectiveArg() throws ParseException { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case IDENTIFIER: |
| case LCURLY: |
| Reference(); |
| break; |
| case WORD: |
| Word(); |
| break; |
| case STRING_LITERAL: |
| StringLiteral(); |
| break; |
| case NUMBER_LITERAL: |
| NumberLiteral(); |
| break; |
| case LBRACKET: |
| ObjectArray(); |
| break; |
| default: |
| jj_la1[3] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| |
| /** |
| * 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; |
| Directive d; |
| try { |
| /* |
| * note that if we were escaped, that is now handled by EscapedDirective() |
| */ |
| |
| t = jj_consume_token(WORD); |
| d = (Directive) directives.get(t.image.substring(1)); |
| |
| /* |
| * set the directive name from here. No reason for the thing to know about parser tokens |
| */ |
| |
| jjtn000.setDirectiveName( t.image.substring(1) ); |
| |
| if (d == null) |
| { |
| token_source.stateStackPop(); |
| token_source.inDirective = false; |
| {if (true) return jjtn000;} |
| } |
| |
| /* |
| * now, switch us out of PRE_DIRECTIVE |
| */ |
| |
| token_source.SwitchTo(DIRECTIVE); |
| jj_consume_token(LPAREN); |
| label_3: |
| while (true) { |
| DirectiveArg(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case LBRACKET: |
| case STRING_LITERAL: |
| case NUMBER_LITERAL: |
| case WORD: |
| case IDENTIFIER: |
| case LCURLY: |
| ; |
| break; |
| default: |
| jj_la1[4] = jj_gen; |
| break label_3; |
| } |
| } |
| jj_consume_token(RPAREN); |
| if (d.getType() == Directive.LINE) |
| {if (true) return jjtn000;} |
| ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK); |
| boolean jjtc001 = true; |
| jjtree.openNodeScope(jjtn001); |
| try { |
| label_4: |
| while (true) { |
| Statement(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case LPAREN: |
| case RPAREN: |
| case ESCAPE_DIRECTIVE: |
| case SET_DIRECTIVE: |
| case DOUBLE_ESCAPE: |
| case ESCAPE: |
| case TEXT: |
| case SINGLE_LINE_COMMENT: |
| case FORMAL_COMMENT: |
| case MULTI_LINE_COMMENT: |
| case STRING_LITERAL: |
| case IF_DIRECTIVE: |
| case STOP_DIRECTIVE: |
| case NUMBER_LITERAL: |
| case WORD: |
| case IDENTIFIER: |
| case DOT: |
| case LCURLY: |
| ; |
| break; |
| default: |
| jj_la1[5] = jj_gen; |
| break label_4; |
| } |
| } |
| } catch (Throwable jjte001) { |
| if (jjtc001) { |
| jjtree.clearNodeScope(jjtn001); |
| jjtc001 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte001 instanceof ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte001;} |
| } |
| {if (true) throw (Error)jjte001;} |
| } finally { |
| if (jjtc001) { |
| jjtree.closeNodeScope(jjtn001, true); |
| } |
| } |
| jj_consume_token(END); |
| 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 ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte000;} |
| } |
| {if (true) throw (Error)jjte000;} |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| } |
| } |
| throw new Error("Missing return statement in function"); |
| } |
| |
| 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 STRING_LITERAL: |
| case TRUE: |
| case FALSE: |
| case NUMBER_LITERAL: |
| case IDENTIFIER: |
| case LCURLY: |
| Parameter(); |
| label_5: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case COMMA: |
| ; |
| break; |
| default: |
| jj_la1[6] = jj_gen; |
| break label_5; |
| } |
| jj_consume_token(COMMA); |
| Parameter(); |
| } |
| break; |
| default: |
| jj_la1[7] = jj_gen; |
| ; |
| } |
| jj_consume_token(RBRACKET); |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 STRING_LITERAL: |
| StringLiteral(); |
| break; |
| case LBRACKET: |
| ObjectArray(); |
| break; |
| case TRUE: |
| True(); |
| break; |
| case FALSE: |
| False(); |
| break; |
| case IDENTIFIER: |
| case LCURLY: |
| Reference(); |
| break; |
| case NUMBER_LITERAL: |
| NumberLiteral(); |
| break; |
| default: |
| jj_la1[8] = 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 STRING_LITERAL: |
| case TRUE: |
| case FALSE: |
| case NUMBER_LITERAL: |
| case IDENTIFIER: |
| case LCURLY: |
| Parameter(); |
| label_6: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case COMMA: |
| ; |
| break; |
| default: |
| jj_la1[9] = jj_gen; |
| break label_6; |
| } |
| jj_consume_token(COMMA); |
| Parameter(); |
| } |
| break; |
| default: |
| jj_la1[10] = jj_gen; |
| ; |
| } |
| jj_consume_token(REFMOD2_RPAREN); |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 LCURLY: |
| jj_consume_token(LCURLY); |
| break; |
| default: |
| jj_la1[11] = jj_gen; |
| ; |
| } |
| jj_consume_token(IDENTIFIER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case RCURLY: |
| jj_consume_token(RCURLY); |
| break; |
| default: |
| jj_la1[12] = jj_gen; |
| ; |
| } |
| label_7: |
| while (true) { |
| if (jj_2_2(2)) { |
| ; |
| } else { |
| break label_7; |
| } |
| jj_consume_token(DOT); |
| if (jj_2_3(3)) { |
| Method(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case IDENTIFIER: |
| Identifier(); |
| break; |
| default: |
| jj_la1[13] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case RCURLY: |
| jj_consume_token(RCURLY); |
| break; |
| default: |
| jj_la1[14] = jj_gen; |
| ; |
| } |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 NUMBER_LITERAL: |
| jj_consume_token(NUMBER_LITERAL); |
| break; |
| case STRING_LITERAL: |
| jj_consume_token(STRING_LITERAL); |
| break; |
| case ESCAPE: |
| jj_consume_token(ESCAPE); |
| break; |
| default: |
| jj_la1[15] = 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); |
| jj_consume_token(LPAREN); |
| Expression(); |
| jj_consume_token(RPAREN); |
| ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK); |
| boolean jjtc001 = true; |
| jjtree.openNodeScope(jjtn001); |
| try { |
| label_8: |
| while (true) { |
| Statement(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case LPAREN: |
| case RPAREN: |
| case ESCAPE_DIRECTIVE: |
| case SET_DIRECTIVE: |
| case DOUBLE_ESCAPE: |
| case ESCAPE: |
| case TEXT: |
| case SINGLE_LINE_COMMENT: |
| case FORMAL_COMMENT: |
| case MULTI_LINE_COMMENT: |
| case STRING_LITERAL: |
| case IF_DIRECTIVE: |
| case STOP_DIRECTIVE: |
| case NUMBER_LITERAL: |
| case WORD: |
| case IDENTIFIER: |
| case DOT: |
| case LCURLY: |
| ; |
| break; |
| default: |
| jj_la1[16] = jj_gen; |
| break label_8; |
| } |
| } |
| } catch (Throwable jjte001) { |
| if (jjtc001) { |
| jjtree.clearNodeScope(jjtn001); |
| jjtc001 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte001 instanceof ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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_9: |
| while (true) { |
| ElseIfStatement(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case ELSEIF_DIRECTIVE: |
| ; |
| break; |
| default: |
| jj_la1[17] = jj_gen; |
| break label_9; |
| } |
| } |
| break; |
| default: |
| jj_la1[18] = jj_gen; |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case ELSE_DIRECTIVE: |
| ElseStatement(); |
| break; |
| default: |
| jj_la1[19] = jj_gen; |
| ; |
| } |
| jj_consume_token(END); |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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_10: |
| while (true) { |
| Statement(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case LPAREN: |
| case RPAREN: |
| case ESCAPE_DIRECTIVE: |
| case SET_DIRECTIVE: |
| case DOUBLE_ESCAPE: |
| case ESCAPE: |
| case TEXT: |
| case SINGLE_LINE_COMMENT: |
| case FORMAL_COMMENT: |
| case MULTI_LINE_COMMENT: |
| case STRING_LITERAL: |
| case IF_DIRECTIVE: |
| case STOP_DIRECTIVE: |
| case NUMBER_LITERAL: |
| case WORD: |
| case IDENTIFIER: |
| case DOT: |
| case LCURLY: |
| ; |
| break; |
| default: |
| jj_la1[20] = jj_gen; |
| break label_10; |
| } |
| } |
| } catch (Throwable jjte001) { |
| if (jjtc001) { |
| jjtree.clearNodeScope(jjtn001); |
| jjtc001 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte001 instanceof ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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); |
| jj_consume_token(LPAREN); |
| Expression(); |
| jj_consume_token(RPAREN); |
| ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK); |
| boolean jjtc001 = true; |
| jjtree.openNodeScope(jjtn001); |
| try { |
| label_11: |
| while (true) { |
| Statement(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case LPAREN: |
| case RPAREN: |
| case ESCAPE_DIRECTIVE: |
| case SET_DIRECTIVE: |
| case DOUBLE_ESCAPE: |
| case ESCAPE: |
| case TEXT: |
| case SINGLE_LINE_COMMENT: |
| case FORMAL_COMMENT: |
| case MULTI_LINE_COMMENT: |
| case STRING_LITERAL: |
| case IF_DIRECTIVE: |
| case STOP_DIRECTIVE: |
| case NUMBER_LITERAL: |
| case WORD: |
| case IDENTIFIER: |
| case DOT: |
| case LCURLY: |
| ; |
| break; |
| default: |
| jj_la1[21] = jj_gen; |
| break label_11; |
| } |
| } |
| } catch (Throwable jjte001) { |
| if (jjtc001) { |
| jjtree.clearNodeScope(jjtn001); |
| jjtc001 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte001 instanceof ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte000;} |
| } |
| {if (true) throw (Error)jjte000;} |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, true); |
| } |
| } |
| } |
| |
| 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); |
| Expression(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case NEWLINE: |
| jj_consume_token(NEWLINE); |
| break; |
| default: |
| jj_la1[22] = jj_gen; |
| ; |
| } |
| } catch (Throwable jjte000) { |
| if (jjtc000) { |
| jjtree.clearNodeScope(jjtn000); |
| jjtc000 = false; |
| } else { |
| jjtree.popNode(); |
| } |
| if (jjte000 instanceof ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 { |
| jj_consume_token(STOP_DIRECTIVE); |
| } |
| |
| /* ----------------------------------------------------------------------- |
| * |
| * Expression Syntax |
| * |
| * ----------------------------------------------------------------------*/ |
| final public void Expression() throws ParseException { |
| /*@bgen(jjtree) Expression */ |
| ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION); |
| boolean jjtc000 = true; |
| jjtree.openNodeScope(jjtn000); |
| try { |
| if (jj_2_4(2147483647)) { |
| Assignment(); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case LBRACKET: |
| case LPAREN: |
| case STRING_LITERAL: |
| case TRUE: |
| case FALSE: |
| case LOGICAL_NOT: |
| case NUMBER_LITERAL: |
| case IDENTIFIER: |
| case LCURLY: |
| ConditionalOrExpression(); |
| break; |
| default: |
| jj_la1[23] = 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 ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 ParseException) { |
| {if (true) throw (ParseException)jjte000;} |
| } |
| if (jjte000 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte000;} |
| } |
| {if (true) throw (Error)jjte000;} |
| } finally { |
| if (jjtc000) { |
| jjtree.closeNodeScope(jjtn000, 2); |
| } |
| } |
| } |
| |
| final public void ConditionalOrExpression() throws ParseException { |
| ConditionalAndExpression(); |
| label_12: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case LOGICAL_OR: |
| ; |
| break; |
| default: |
| jj_la1[24] = jj_gen; |
| break label_12; |
| } |
| 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 ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte001;} |
| } |
| {if (true) throw (Error)jjte001;} |
| } finally { |
| if (jjtc001) { |
| jjtree.closeNodeScope(jjtn001, 2); |
| } |
| } |
| } |
| } |
| |
| final public void ConditionalAndExpression() throws ParseException { |
| EqualityExpression(); |
| label_13: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case LOGICAL_AND: |
| ; |
| break; |
| default: |
| jj_la1[25] = jj_gen; |
| break label_13; |
| } |
| 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 ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte001;} |
| } |
| {if (true) throw (Error)jjte001;} |
| } finally { |
| if (jjtc001) { |
| jjtree.closeNodeScope(jjtn001, 2); |
| } |
| } |
| } |
| } |
| |
| final public void EqualityExpression() throws ParseException { |
| RelationalExpression(); |
| label_14: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case LOGICAL_EQUALS: |
| case LOGICAL_NOT_EQUALS: |
| ; |
| break; |
| default: |
| jj_la1[26] = jj_gen; |
| break label_14; |
| } |
| 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 ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 ParseException) { |
| {if (true) throw (ParseException)jjte002;} |
| } |
| if (jjte002 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte002;} |
| } |
| {if (true) throw (Error)jjte002;} |
| } finally { |
| if (jjtc002) { |
| jjtree.closeNodeScope(jjtn002, 2); |
| } |
| } |
| break; |
| default: |
| jj_la1[27] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| |
| final public void RelationalExpression() throws ParseException { |
| AdditiveExpression(); |
| label_15: |
| 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[28] = jj_gen; |
| break label_15; |
| } |
| 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 ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 ParseException) { |
| {if (true) throw (ParseException)jjte002;} |
| } |
| if (jjte002 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 ParseException) { |
| {if (true) throw (ParseException)jjte003;} |
| } |
| if (jjte003 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 ParseException) { |
| {if (true) throw (ParseException)jjte004;} |
| } |
| if (jjte004 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte004;} |
| } |
| {if (true) throw (Error)jjte004;} |
| } finally { |
| if (jjtc004) { |
| jjtree.closeNodeScope(jjtn004, 2); |
| } |
| } |
| break; |
| default: |
| jj_la1[29] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| |
| final public void AdditiveExpression() throws ParseException { |
| MultiplicativeExpression(); |
| label_16: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case MINUS: |
| case PLUS: |
| ; |
| break; |
| default: |
| jj_la1[30] = jj_gen; |
| break label_16; |
| } |
| 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 ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 ParseException) { |
| {if (true) throw (ParseException)jjte002;} |
| } |
| if (jjte002 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte002;} |
| } |
| {if (true) throw (Error)jjte002;} |
| } finally { |
| if (jjtc002) { |
| jjtree.closeNodeScope(jjtn002, 2); |
| } |
| } |
| break; |
| default: |
| jj_la1[31] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| |
| final public void MultiplicativeExpression() throws ParseException { |
| UnaryExpression(); |
| label_17: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case MULTIPLY: |
| case DIVIDE: |
| case MODULUS: |
| ; |
| break; |
| default: |
| jj_la1[32] = jj_gen; |
| break label_17; |
| } |
| 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 ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 ParseException) { |
| {if (true) throw (ParseException)jjte002;} |
| } |
| if (jjte002 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)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 ParseException) { |
| {if (true) throw (ParseException)jjte003;} |
| } |
| if (jjte003 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte003;} |
| } |
| {if (true) throw (Error)jjte003;} |
| } finally { |
| if (jjtc003) { |
| jjtree.closeNodeScope(jjtn003, 2); |
| } |
| } |
| break; |
| default: |
| jj_la1[33] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| |
| final public void UnaryExpression() throws 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 ParseException) { |
| {if (true) throw (ParseException)jjte001;} |
| } |
| if (jjte001 instanceof RuntimeException) { |
| {if (true) throw (RuntimeException)jjte001;} |
| } |
| {if (true) throw (Error)jjte001;} |
| } finally { |
| if (jjtc001) { |
| jjtree.closeNodeScope(jjtn001, 1); |
| } |
| } |
| break; |
| case LBRACKET: |
| case LPAREN: |
| case STRING_LITERAL: |
| case TRUE: |
| case FALSE: |
| case NUMBER_LITERAL: |
| case IDENTIFIER: |
| case LCURLY: |
| PrimaryExpression(); |
| break; |
| default: |
| jj_la1[34] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| |
| final public void PrimaryExpression() throws ParseException { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case STRING_LITERAL: |
| StringLiteral(); |
| break; |
| case NUMBER_LITERAL: |
| NumberLiteral(); |
| break; |
| case IDENTIFIER: |
| case LCURLY: |
| Reference(); |
| 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[35] = jj_gen; |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| |
| final private boolean jj_2_1(int xla) { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| boolean retval = !jj_3_1(); |
| jj_save(0, xla); |
| return retval; |
| } |
| |
| final private boolean jj_2_2(int xla) { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| boolean retval = !jj_3_2(); |
| jj_save(1, xla); |
| return retval; |
| } |
| |
| final private boolean jj_2_3(int xla) { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| boolean retval = !jj_3_3(); |
| jj_save(2, xla); |
| return retval; |
| } |
| |
| final private boolean jj_2_4(int xla) { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| boolean retval = !jj_3_4(); |
| jj_save(3, xla); |
| return retval; |
| } |
| |
| final private boolean jj_3R_23() { |
| if (jj_3R_31()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_20() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_23()) { |
| jj_scanpos = xsp; |
| if (jj_3R_24()) { |
| jj_scanpos = xsp; |
| if (jj_3R_25()) { |
| jj_scanpos = xsp; |
| if (jj_3R_26()) { |
| jj_scanpos = xsp; |
| if (jj_3R_27()) { |
| jj_scanpos = xsp; |
| if (jj_3R_28()) { |
| jj_scanpos = xsp; |
| if (jj_3R_29()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_75() { |
| if (jj_3R_20()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_78() { |
| if (jj_scan_token(MODULUS)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_70()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_74() { |
| if (jj_scan_token(LOGICAL_NOT)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_70()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_70() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_74()) { |
| jj_scanpos = xsp; |
| if (jj_3R_75()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_77() { |
| if (jj_scan_token(DIVIDE)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_70()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_18() { |
| if (jj_3R_21()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_76() { |
| if (jj_scan_token(MULTIPLY)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_70()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_71() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_76()) { |
| jj_scanpos = xsp; |
| if (jj_3R_77()) { |
| jj_scanpos = xsp; |
| if (jj_3R_78()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_73() { |
| if (jj_scan_token(MINUS)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_64()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_64() { |
| if (jj_3R_70()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_71()) { jj_scanpos = xsp; break; } |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3R_72() { |
| if (jj_scan_token(PLUS)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_64()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_65() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_72()) { |
| jj_scanpos = xsp; |
| if (jj_3R_73()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_69() { |
| if (jj_scan_token(LOGICAL_GE)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_60()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_60() { |
| if (jj_3R_64()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_65()) { jj_scanpos = xsp; break; } |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3R_57() { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_30()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_68() { |
| if (jj_scan_token(LOGICAL_LE)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_60()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_67() { |
| if (jj_scan_token(LOGICAL_GT)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_60()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_66() { |
| if (jj_scan_token(LOGICAL_LT)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_60()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_61() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_66()) { |
| jj_scanpos = xsp; |
| if (jj_3R_67()) { |
| jj_scanpos = xsp; |
| if (jj_3R_68()) { |
| jj_scanpos = xsp; |
| if (jj_3R_69()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3_1() { |
| if (jj_scan_token(DOUBLE_ESCAPE)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3_3() { |
| if (jj_3R_19()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_63() { |
| if (jj_scan_token(LOGICAL_NOT_EQUALS)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_58()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_58() { |
| if (jj_3R_60()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_61()) { jj_scanpos = xsp; break; } |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3R_62() { |
| if (jj_scan_token(LOGICAL_EQUALS)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_58()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_59() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_62()) { |
| jj_scanpos = xsp; |
| if (jj_3R_63()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_22() { |
| if (jj_3R_30()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_57()) { jj_scanpos = xsp; break; } |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3R_36() { |
| if (jj_scan_token(FALSE)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_55() { |
| if (jj_3R_58()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_59()) { jj_scanpos = xsp; break; } |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3R_35() { |
| if (jj_scan_token(TRUE)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_56() { |
| if (jj_scan_token(LOGICAL_AND)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_55()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3_2() { |
| if (jj_scan_token(DOT)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3_3()) { |
| jj_scanpos = xsp; |
| if (jj_3R_18()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| xsp = jj_scanpos; |
| if (jj_3R_49()) jj_scanpos = xsp; |
| else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_45() { |
| if (jj_scan_token(RCURLY)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_53() { |
| if (jj_3R_55()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_56()) { jj_scanpos = xsp; break; } |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3R_44() { |
| if (jj_scan_token(LCURLY)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_54() { |
| if (jj_scan_token(LOGICAL_OR)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_53()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_33() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_44()) jj_scanpos = xsp; |
| else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_scan_token(IDENTIFIER)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| xsp = jj_scanpos; |
| if (jj_3R_45()) jj_scanpos = xsp; |
| else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3_2()) { jj_scanpos = xsp; break; } |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3_4() { |
| if (jj_3R_20()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_scan_token(EQUALS)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_52() { |
| if (jj_3R_53()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_54()) { jj_scanpos = xsp; break; } |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3R_50() { |
| if (jj_scan_token(COMMA)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_30()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_51() { |
| if (jj_3R_20()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_scan_token(EQUALS)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_37()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_19() { |
| if (jj_3R_21()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_22()) jj_scanpos = xsp; |
| else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_scan_token(REFMOD2_RPAREN)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_48() { |
| if (jj_3R_52()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_21() { |
| if (jj_scan_token(IDENTIFIER)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_47() { |
| if (jj_3R_51()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_37() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_47()) { |
| jj_scanpos = xsp; |
| if (jj_3R_48()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_43() { |
| if (jj_3R_32()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_42() { |
| if (jj_3R_33()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_46() { |
| if (jj_3R_30()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| while (true) { |
| xsp = jj_scanpos; |
| if (jj_3R_50()) { jj_scanpos = xsp; break; } |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } |
| return false; |
| } |
| |
| final private boolean jj_3R_41() { |
| if (jj_3R_36()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_40() { |
| if (jj_3R_35()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_39() { |
| if (jj_3R_34()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_38() { |
| if (jj_3R_31()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_30() { |
| Token xsp; |
| xsp = jj_scanpos; |
| 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()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_31() { |
| if (jj_scan_token(STRING_LITERAL)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_34() { |
| if (jj_scan_token(LBRACKET)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_46()) jj_scanpos = xsp; |
| else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_scan_token(RBRACKET)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_32() { |
| if (jj_scan_token(NUMBER_LITERAL)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_49() { |
| if (jj_scan_token(RCURLY)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_29() { |
| if (jj_scan_token(LPAREN)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_3R_37()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| if (jj_scan_token(RPAREN)) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_28() { |
| if (jj_3R_36()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_27() { |
| if (jj_3R_35()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_26() { |
| if (jj_3R_34()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_25() { |
| if (jj_3R_33()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| final private boolean jj_3R_24() { |
| if (jj_3R_32()) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; |
| return false; |
| } |
| |
| public ParserTokenManager token_source; |
| ASCII_CharStream jj_input_stream; |
| 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[36]; |
| final private int[] jj_la1_0 = {0x11f81b0,0x11f81b0,0x1c0000,0x1000002,0x1000002,0x11f81b0,0x8,0x7000002,0x7000002,0x8,0x7000002,0x0,0x0,0x0,0x0,0x1030030,0x11f81b0,0x0,0x0,0x0,0x11f81b0,0x11f81b0,0x8000000,0x7000012,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0x30000000,0xc0000000,0xc0000000,0x7000012,0x7000012,}; |
| final private int[] jj_la1_1 = {0x38a9000,0x38a9000,0x0,0x28a0000,0x28a0000,0x38a9000,0x0,0x2820000,0x2820000,0x0,0x2820000,0x2000000,0x4000000,0x800000,0x4000000,0x1020000,0x38a9000,0x2000,0x2000,0x4000,0x38a9000,0x38a9000,0x0,0x2820200,0x4,0x2,0x180,0x180,0x78,0x78,0x0,0x0,0x1,0x1,0x2820200,0x2820000,}; |
| final private JJCalls[] jj_2_rtns = new JJCalls[4]; |
| private boolean jj_rescan = false; |
| private int jj_gc = 0; |
| |
| public Parser(java.io.InputStream stream) { |
| jj_input_stream = new ASCII_CharStream(stream, 1, 1); |
| token_source = new ParserTokenManager(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 36; i++) jj_la1[i] = -1; |
| for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); |
| } |
| |
| public void ReInit(java.io.InputStream stream) { |
| jj_input_stream.ReInit(stream, 1, 1); |
| token_source.ReInit(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jjtree.reset(); |
| jj_gen = 0; |
| for (int i = 0; i < 36; i++) jj_la1[i] = -1; |
| for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); |
| } |
| |
| public Parser(java.io.Reader stream) { |
| jj_input_stream = new ASCII_CharStream(stream, 1, 1); |
| token_source = new ParserTokenManager(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jj_gen = 0; |
| for (int i = 0; i < 36; i++) jj_la1[i] = -1; |
| for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); |
| } |
| |
| public void ReInit(java.io.Reader stream) { |
| jj_input_stream.ReInit(stream, 1, 1); |
| token_source.ReInit(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jjtree.reset(); |
| jj_gen = 0; |
| for (int i = 0; i < 36; 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 < 36; 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 < 36; 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(); |
| } |
| |
| 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); |
| } |
| return (jj_scanpos.kind != kind); |
| } |
| |
| 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 enum = jj_expentries.elements(); enum.hasMoreElements();) { |
| int[] oldentry = (int[])(enum.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; |
| } |
| } |
| |
| final public ParseException generateParseException() { |
| jj_expentries.removeAllElements(); |
| boolean[] la1tokens = new boolean[61]; |
| for (int i = 0; i < 61; i++) { |
| la1tokens[i] = false; |
| } |
| if (jj_kind >= 0) { |
| la1tokens[jj_kind] = true; |
| jj_kind = -1; |
| } |
| for (int i = 0; i < 36; 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; |
| } |
| } |
| } |
| } |
| for (int i = 0; i < 61; i++) { |
| if (la1tokens[i]) { |
| jj_expentry = new int[1]; |
| jj_expentry[0] = i; |
| jj_expentries.addElement(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] = (int[])jj_expentries.elementAt(i); |
| } |
| return new ParseException(token, exptokseq, tokenImage); |
| } |
| |
| final public void enable_tracing() { |
| } |
| |
| final public void disable_tracing() { |
| } |
| |
| final private void jj_rescan_token() { |
| jj_rescan = true; |
| for (int i = 0; i < 4; i++) { |
| 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; |
| } |
| } |
| 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; |
| } |
| |
| } |
