0001: /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
0002: package org.apache.velocity.runtime.parser;
0003:
0004: import java.io.*;
0005: import java.util.*;
0006:
0007: import org.apache.velocity.runtime.RuntimeServices;
0008: import org.apache.velocity.runtime.parser.node.*;
0009: import org.apache.velocity.runtime.directive.Directive;
0010: import org.apache.velocity.runtime.directive.Macro;
0011: import org.apache.velocity.runtime.directive.MacroParseException;
0012: import org.apache.velocity.util.StringUtils;
0013:
0014: /**
0015: * This class is responsible for parsing a Velocity
0016: * template. This class was generated by JavaCC using
0017: * the JJTree extension to produce an Abstract
0018: * Syntax Tree (AST) of the template.
0019: *
0020: * Please look at the Parser.jjt file which is
0021: * what controls the generation of this class.
0022: *
0023: * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
0024: * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
0025: * @author <a href="hps@intermeta.de">Henning P. Schmiedehausen</a>
0026: * @version $Id: Parser.java 463419 2006-10-12 20:39:49Z henning $
0027: */
0028: public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants,
0029: ParserConstants {/*@bgen(jjtree)*/
0030: protected JJTParserState jjtree = new JJTParserState();
0031: /**
0032: * This Hashtable contains a list of all of the dynamic directives.
0033: */
0034: private Hashtable directives = new Hashtable(0);
0035:
0036: /**
0037: * Name of current template we are parsing. Passed to us in parse()
0038: */
0039: String currentTemplateName = "";
0040:
0041: VelocityCharStream velcharstream = null;
0042:
0043: private RuntimeServices rsvc = null;
0044:
0045: /**
0046: * This constructor was added to allow the re-use of parsers.
0047: * The normal constructor takes a single argument which
0048: * an InputStream. This simply creates a re-usable parser
0049: * object, we satisfy the requirement of an InputStream
0050: * by using a newline character as an input stream.
0051: */
0052: public Parser(RuntimeServices rs) {
0053: /*
0054: * need to call the CTOR first thing.
0055: */
0056:
0057: this (new VelocityCharStream(new ByteArrayInputStream("\n"
0058: .getBytes()), 1, 1));
0059:
0060: /*
0061: * now setup a VCS for later use
0062: */
0063: velcharstream = new VelocityCharStream(
0064: new ByteArrayInputStream("\n".getBytes()), 1, 1);
0065:
0066: /*
0067: * and save the RuntimeServices
0068: */
0069: rsvc = rs;
0070: }
0071:
0072: /**
0073: * This was also added to allow parsers to be
0074: * re-usable. Normal JavaCC use entails passing an
0075: * input stream to the constructor and the parsing
0076: * process is carried out once. We want to be able
0077: * to re-use parsers: we do this by adding this
0078: * method and re-initializing the lexer with
0079: * the new stream that we want parsed.
0080: */
0081: public SimpleNode parse(Reader reader, String templateName)
0082: throws ParseException {
0083: SimpleNode sn = null;
0084:
0085: currentTemplateName = templateName;
0086:
0087: try {
0088: token_source.clearStateVars();
0089:
0090: /*
0091: * reinitialize the VelocityCharStream
0092: * with the new reader
0093: */
0094: velcharstream.ReInit(reader, 1, 1);
0095:
0096: /*
0097: * now reinit the Parser with this CharStream
0098: */
0099: ReInit(velcharstream);
0100:
0101: /*
0102: * do that voodoo...
0103: */
0104: sn = process();
0105: } catch (MacroParseException mee) {
0106: /*
0107: * thrown by the Macro class when something is amiss in the
0108: * Macro specification
0109: */
0110: rsvc.getLog().error(
0111: "Parser Error: #macro() : " + templateName, mee);
0112: throw mee;
0113: } catch (ParseException pe) {
0114: rsvc.getLog()
0115: .error("Parser Exception: " + templateName, pe);
0116: throw new TemplateParseException(pe.currentToken,
0117: pe.expectedTokenSequences, pe.tokenImage,
0118: currentTemplateName);
0119: } catch (TokenMgrError tme) {
0120: throw new ParseException("Lexical error: " + tme.toString());
0121: } catch (Exception e) {
0122: rsvc.getLog().error("Parser Error: " + templateName, e);
0123: }
0124:
0125: currentTemplateName = "";
0126:
0127: return sn;
0128: }
0129:
0130: /**
0131: * This method sets the directives Hashtable
0132: */
0133: public void setDirectives(Hashtable directives) {
0134: this .directives = directives;
0135: }
0136:
0137: /**
0138: * This method gets a Directive from the directives Hashtable
0139: */
0140: public Directive getDirective(String directive) {
0141: return (Directive) directives.get(directive);
0142: }
0143:
0144: /**
0145: * This method finds out of the directive exists in the directives
0146: * Hashtable.
0147: */
0148: public boolean isDirective(String directive) {
0149: return directives.containsKey(directive);
0150: }
0151:
0152: /**
0153: * Produces a processed output for an escaped control or
0154: * pluggable directive
0155: */
0156: private String escapedDirective(String strImage) {
0157: int iLast = strImage.lastIndexOf("\\");
0158:
0159: String strDirective = strImage.substring(iLast + 1);
0160:
0161: boolean bRecognizedDirective = false;
0162:
0163: /*
0164: * is this a PD or a control directive?
0165: */
0166:
0167: if (isDirective(strDirective.substring(1))) {
0168: bRecognizedDirective = true;
0169: } else if (rsvc.isVelocimacro(strDirective.substring(1),
0170: currentTemplateName)) {
0171: bRecognizedDirective = true;
0172: } else {
0173: /* order for speed? */
0174:
0175: if (strDirective.substring(1).equals("if")
0176: || strDirective.substring(1).equals("end")
0177: || strDirective.substring(1).equals("set")
0178: || strDirective.substring(1).equals("else")
0179: || strDirective.substring(1).equals("elseif")
0180: || strDirective.substring(1).equals("stop")) {
0181: bRecognizedDirective = true;
0182: }
0183: }
0184:
0185: /*
0186: * if so, make the proper prefix string (let the escapes do their thing..)
0187: * otherwise, just return what it is..
0188: */
0189:
0190: if (bRecognizedDirective)
0191: return (strImage.substring(0, iLast / 2) + strDirective);
0192: else
0193: return (strImage);
0194: }
0195:
0196: /**
0197: * This method is what starts the whole parsing
0198: * process. After the parsing is complete and
0199: * the template has been turned into an AST,
0200: * this method returns the root of AST which
0201: * can subsequently be traversed by a visitor
0202: * which implements the ParserVisitor interface
0203: * which is generated automatically by JavaCC
0204: */
0205: final public SimpleNode process() throws ParseException {
0206: /*@bgen(jjtree) process */
0207: ASTprocess jjtn000 = new ASTprocess(this , JJTPROCESS);
0208: boolean jjtc000 = true;
0209: jjtree.openNodeScope(jjtn000);
0210: try {
0211: label_1: while (true) {
0212: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0213: case LPAREN:
0214: case RPAREN:
0215: case ESCAPE_DIRECTIVE:
0216: case SET_DIRECTIVE:
0217: case SINGLE_LINE_COMMENT_START:
0218: case DOUBLE_ESCAPE:
0219: case ESCAPE:
0220: case TEXT:
0221: case FORMAL_COMMENT:
0222: case MULTI_LINE_COMMENT:
0223: case STRING_LITERAL:
0224: case IF_DIRECTIVE:
0225: case STOP_DIRECTIVE:
0226: case INTEGER_LITERAL:
0227: case FLOATING_POINT_LITERAL:
0228: case WORD:
0229: case BRACKETED_WORD:
0230: case IDENTIFIER:
0231: case DOT:
0232: case LCURLY:
0233: case RCURLY:
0234: ;
0235: break;
0236: default:
0237: jj_la1[0] = jj_gen;
0238: break label_1;
0239: }
0240: Statement();
0241: }
0242: jj_consume_token(0);
0243: jjtree.closeNodeScope(jjtn000, true);
0244: jjtc000 = false;
0245: {
0246: if (true)
0247: return jjtn000;
0248: }
0249: } catch (Throwable jjte000) {
0250: if (jjtc000) {
0251: jjtree.clearNodeScope(jjtn000);
0252: jjtc000 = false;
0253: } else {
0254: jjtree.popNode();
0255: }
0256: if (jjte000 instanceof RuntimeException) {
0257: {
0258: if (true)
0259: throw (RuntimeException) jjte000;
0260: }
0261: }
0262: if (jjte000 instanceof ParseException) {
0263: {
0264: if (true)
0265: throw (ParseException) jjte000;
0266: }
0267: }
0268: {
0269: if (true)
0270: throw (Error) jjte000;
0271: }
0272: } finally {
0273: if (jjtc000) {
0274: jjtree.closeNodeScope(jjtn000, true);
0275: }
0276: }
0277: throw new Error("Missing return statement in function");
0278: }
0279:
0280: /**
0281: * These are the types of statements that
0282: * are acceptable in Velocity templates.
0283: */
0284: final public void Statement() throws ParseException {
0285: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0286: case IF_DIRECTIVE:
0287: IfStatement();
0288: break;
0289: case STOP_DIRECTIVE:
0290: StopStatement();
0291: break;
0292: default:
0293: jj_la1[1] = jj_gen;
0294: if (jj_2_1(2)) {
0295: Reference();
0296: } else {
0297: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0298: case SINGLE_LINE_COMMENT_START:
0299: case FORMAL_COMMENT:
0300: case MULTI_LINE_COMMENT:
0301: Comment();
0302: break;
0303: case SET_DIRECTIVE:
0304: SetDirective();
0305: break;
0306: case ESCAPE_DIRECTIVE:
0307: EscapedDirective();
0308: break;
0309: case DOUBLE_ESCAPE:
0310: Escape();
0311: break;
0312: case WORD:
0313: case BRACKETED_WORD:
0314: Directive();
0315: break;
0316: case LPAREN:
0317: case RPAREN:
0318: case ESCAPE:
0319: case TEXT:
0320: case STRING_LITERAL:
0321: case INTEGER_LITERAL:
0322: case FLOATING_POINT_LITERAL:
0323: case DOT:
0324: case LCURLY:
0325: case RCURLY:
0326: Text();
0327: break;
0328: default:
0329: jj_la1[2] = jj_gen;
0330: jj_consume_token(-1);
0331: throw new ParseException();
0332: }
0333: }
0334: }
0335: }
0336:
0337: /**
0338: * used to separate the notion of a valid directive that has been
0339: * escaped, versus something that looks like a directive and
0340: * is just schmoo. This is important to do as a separate production
0341: * that creates a node, because we want this, in either case, to stop
0342: * the further parsing of the Directive() tree.
0343: */
0344: final public void EscapedDirective() throws ParseException {
0345: /*@bgen(jjtree) EscapedDirective */
0346: ASTEscapedDirective jjtn000 = new ASTEscapedDirective(this ,
0347: JJTESCAPEDDIRECTIVE);
0348: boolean jjtc000 = true;
0349: jjtree.openNodeScope(jjtn000);
0350: try {
0351: Token t = null;
0352: t = jj_consume_token(ESCAPE_DIRECTIVE);
0353: jjtree.closeNodeScope(jjtn000, true);
0354: jjtc000 = false;
0355: /*
0356: * churn and burn..
0357: */
0358: t.image = escapedDirective(t.image);
0359: } finally {
0360: if (jjtc000) {
0361: jjtree.closeNodeScope(jjtn000, true);
0362: }
0363: }
0364: }
0365:
0366: /**
0367: * Used to catch and process escape sequences in grammatical constructs
0368: * as escapes outside of VTL are just characters. Right now we have both
0369: * this and the EscapeDirective() construction because in the EscapeDirective()
0370: * case, we want to suck in the #<directive> and here we don't. We just want
0371: * the escapes to render correctly
0372: */
0373: final public void Escape() throws ParseException {
0374: /*@bgen(jjtree) Escape */
0375: ASTEscape jjtn000 = new ASTEscape(this , JJTESCAPE);
0376: boolean jjtc000 = true;
0377: jjtree.openNodeScope(jjtn000);
0378: try {
0379: Token t = null;
0380: int count = 0;
0381: boolean control = false;
0382: label_2: while (true) {
0383: t = jj_consume_token(DOUBLE_ESCAPE);
0384: count++;
0385: if (jj_2_2(2)) {
0386: ;
0387: } else {
0388: break label_2;
0389: }
0390: }
0391: jjtree.closeNodeScope(jjtn000, true);
0392: jjtc000 = false;
0393: /*
0394: * first, check to see if we have a control directive
0395: */
0396: switch (t.next.kind) {
0397: case IF_DIRECTIVE:
0398: case ELSE_DIRECTIVE:
0399: case ELSEIF_DIRECTIVE:
0400: case END:
0401: case STOP_DIRECTIVE:
0402: control = true;
0403: break;
0404: }
0405:
0406: /*
0407: * if that failed, lets lookahead to see if we matched a PD or a VM
0408: */
0409:
0410: if (isDirective(t.next.image.substring(1)))
0411: control = true;
0412: else if (rsvc.isVelocimacro(t.next.image.substring(1),
0413: currentTemplateName))
0414: control = true;
0415:
0416: jjtn000.val = "";
0417:
0418: for (int i = 0; i < count; i++)
0419: jjtn000.val += (control ? "\\" : "\\\\");
0420: } finally {
0421: if (jjtc000) {
0422: jjtree.closeNodeScope(jjtn000, true);
0423: }
0424: }
0425: }
0426:
0427: final public void Comment() throws ParseException {
0428: /*@bgen(jjtree) Comment */
0429: ASTComment jjtn000 = new ASTComment(this , JJTCOMMENT);
0430: boolean jjtc000 = true;
0431: jjtree.openNodeScope(jjtn000);
0432: try {
0433: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0434: case SINGLE_LINE_COMMENT_START:
0435: jj_consume_token(SINGLE_LINE_COMMENT_START);
0436: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0437: case SINGLE_LINE_COMMENT:
0438: jj_consume_token(SINGLE_LINE_COMMENT);
0439: break;
0440: default:
0441: jj_la1[3] = jj_gen;
0442: ;
0443: }
0444: break;
0445: case MULTI_LINE_COMMENT:
0446: jj_consume_token(MULTI_LINE_COMMENT);
0447: break;
0448: case FORMAL_COMMENT:
0449: jj_consume_token(FORMAL_COMMENT);
0450: break;
0451: default:
0452: jj_la1[4] = jj_gen;
0453: jj_consume_token(-1);
0454: throw new ParseException();
0455: }
0456: } finally {
0457: if (jjtc000) {
0458: jjtree.closeNodeScope(jjtn000, true);
0459: }
0460: }
0461: }
0462:
0463: final public void FloatingPointLiteral() throws ParseException {
0464: /*@bgen(jjtree) FloatingPointLiteral */
0465: ASTFloatingPointLiteral jjtn000 = new ASTFloatingPointLiteral(
0466: this , JJTFLOATINGPOINTLITERAL);
0467: boolean jjtc000 = true;
0468: jjtree.openNodeScope(jjtn000);
0469: try {
0470: jj_consume_token(FLOATING_POINT_LITERAL);
0471: } finally {
0472: if (jjtc000) {
0473: jjtree.closeNodeScope(jjtn000, true);
0474: }
0475: }
0476: }
0477:
0478: final public void IntegerLiteral() throws ParseException {
0479: /*@bgen(jjtree) IntegerLiteral */
0480: ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(this ,
0481: JJTINTEGERLITERAL);
0482: boolean jjtc000 = true;
0483: jjtree.openNodeScope(jjtn000);
0484: try {
0485: jj_consume_token(INTEGER_LITERAL);
0486: } finally {
0487: if (jjtc000) {
0488: jjtree.closeNodeScope(jjtn000, true);
0489: }
0490: }
0491: }
0492:
0493: final public void StringLiteral() throws ParseException {
0494: /*@bgen(jjtree) StringLiteral */
0495: ASTStringLiteral jjtn000 = new ASTStringLiteral(this ,
0496: JJTSTRINGLITERAL);
0497: boolean jjtc000 = true;
0498: jjtree.openNodeScope(jjtn000);
0499: try {
0500: jj_consume_token(STRING_LITERAL);
0501: } finally {
0502: if (jjtc000) {
0503: jjtree.closeNodeScope(jjtn000, true);
0504: }
0505: }
0506: }
0507:
0508: /**
0509: * This method corresponds to variable
0510: * references in Velocity templates.
0511: * The following are examples of variable
0512: * references that may be found in a
0513: * template:
0514: *
0515: * $foo
0516: * $bar
0517: *
0518: */
0519: final public void Identifier() throws ParseException {
0520: /*@bgen(jjtree) Identifier */
0521: ASTIdentifier jjtn000 = new ASTIdentifier(this , JJTIDENTIFIER);
0522: boolean jjtc000 = true;
0523: jjtree.openNodeScope(jjtn000);
0524: try {
0525: jj_consume_token(IDENTIFIER);
0526: } finally {
0527: if (jjtc000) {
0528: jjtree.closeNodeScope(jjtn000, true);
0529: }
0530: }
0531: }
0532:
0533: final public void Word() throws ParseException {
0534: /*@bgen(jjtree) Word */
0535: ASTWord jjtn000 = new ASTWord(this , JJTWORD);
0536: boolean jjtc000 = true;
0537: jjtree.openNodeScope(jjtn000);
0538: try {
0539: jj_consume_token(WORD);
0540: } finally {
0541: if (jjtc000) {
0542: jjtree.closeNodeScope(jjtn000, true);
0543: }
0544: }
0545: }
0546:
0547: /**
0548: * Supports the arguments for the Pluggable Directives
0549: */
0550: final public int DirectiveArg() throws ParseException {
0551: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0552: case IDENTIFIER:
0553: case LCURLY:
0554: Reference();
0555: {
0556: if (true)
0557: return ParserTreeConstants.JJTREFERENCE;
0558: }
0559: break;
0560: case WORD:
0561: Word();
0562: {
0563: if (true)
0564: return ParserTreeConstants.JJTWORD;
0565: }
0566: break;
0567: case STRING_LITERAL:
0568: StringLiteral();
0569: {
0570: if (true)
0571: return ParserTreeConstants.JJTSTRINGLITERAL;
0572: }
0573: break;
0574: case INTEGER_LITERAL:
0575: IntegerLiteral();
0576: {
0577: if (true)
0578: return ParserTreeConstants.JJTINTEGERLITERAL;
0579: }
0580: break;
0581: default:
0582: jj_la1[5] = jj_gen;
0583: if (jj_2_3(2147483647)) {
0584: IntegerRange();
0585: {
0586: if (true)
0587: return ParserTreeConstants.JJTINTEGERRANGE;
0588: }
0589: } else {
0590: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0591: case FLOATING_POINT_LITERAL:
0592: FloatingPointLiteral();
0593: {
0594: if (true)
0595: return ParserTreeConstants.JJTFLOATINGPOINTLITERAL;
0596: }
0597: break;
0598: case LEFT_CURLEY:
0599: Map();
0600: {
0601: if (true)
0602: return ParserTreeConstants.JJTMAP;
0603: }
0604: break;
0605: case LBRACKET:
0606: ObjectArray();
0607: {
0608: if (true)
0609: return ParserTreeConstants.JJTOBJECTARRAY;
0610: }
0611: break;
0612: case TRUE:
0613: True();
0614: {
0615: if (true)
0616: return ParserTreeConstants.JJTTRUE;
0617: }
0618: break;
0619: case FALSE:
0620: False();
0621: {
0622: if (true)
0623: return ParserTreeConstants.JJTFALSE;
0624: }
0625: break;
0626: default:
0627: jj_la1[6] = jj_gen;
0628: jj_consume_token(-1);
0629: throw new ParseException();
0630: }
0631: }
0632: }
0633: throw new Error("Missing return statement in function");
0634: }
0635:
0636: /**
0637: * Supports the Pluggable Directives
0638: * #foo( arg+ )
0639: */
0640: final public SimpleNode Directive() throws ParseException {
0641: /*@bgen(jjtree) Directive */
0642: ASTDirective jjtn000 = new ASTDirective(this , JJTDIRECTIVE);
0643: boolean jjtc000 = true;
0644: jjtree.openNodeScope(jjtn000);
0645: Token t = null;
0646: int argType;
0647: int argPos = 0;
0648: Directive d;
0649: int directiveType;
0650: boolean isVM = false;
0651: boolean doItNow = false;
0652: try {
0653: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0654: case WORD:
0655: t = jj_consume_token(WORD);
0656: break;
0657: case BRACKETED_WORD:
0658: t = jj_consume_token(BRACKETED_WORD);
0659: break;
0660: default:
0661: jj_la1[7] = jj_gen;
0662: jj_consume_token(-1);
0663: throw new ParseException();
0664: }
0665: String directiveName;
0666: if (t.kind == ParserConstants.BRACKETED_WORD) {
0667: directiveName = t.image.substring(2,
0668: t.image.length() - 1);
0669: } else {
0670: directiveName = t.image.substring(1);
0671: }
0672:
0673: d = (Directive) directives.get(directiveName);
0674:
0675: /*
0676: * Velocimacro support : if the directive is macro directive
0677: * then set the flag so after the block parsing, we add the VM
0678: * right then. (So available if used w/in the current template )
0679: */
0680:
0681: if (directiveName.equals("macro")) {
0682: doItNow = true;
0683: }
0684:
0685: /*
0686: * set the directive name from here. No reason for the thing to know
0687: * about parser tokens
0688: */
0689:
0690: jjtn000.setDirectiveName(directiveName);
0691:
0692: if (d == null) {
0693: /*
0694: * if null, then not a real directive, but maybe a Velocimacro
0695: */
0696:
0697: isVM = rsvc.isVelocimacro(directiveName,
0698: currentTemplateName);
0699:
0700: if (!isVM) {
0701: token_source.stateStackPop();
0702: token_source.inDirective = false;
0703: {
0704: if (true)
0705: return jjtn000;
0706: }
0707: }
0708:
0709: /*
0710: * Currently, all VMs are LINE directives
0711: */
0712:
0713: directiveType = Directive.LINE;
0714: } else {
0715: directiveType = d.getType();
0716: }
0717:
0718: /*
0719: * now, switch us out of PRE_DIRECTIVE
0720: */
0721:
0722: token_source.SwitchTo(DIRECTIVE);
0723:
0724: argPos = 0;
0725: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0726: case WHITESPACE:
0727: jj_consume_token(WHITESPACE);
0728: break;
0729: default:
0730: jj_la1[8] = jj_gen;
0731: ;
0732: }
0733: jj_consume_token(LPAREN);
0734: label_3: while (true) {
0735: if (jj_2_4(2)) {
0736: ;
0737: } else {
0738: break label_3;
0739: }
0740: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0741: case WHITESPACE:
0742: jj_consume_token(WHITESPACE);
0743: break;
0744: default:
0745: jj_la1[9] = jj_gen;
0746: ;
0747: }
0748: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0749: case COMMA:
0750: jj_consume_token(COMMA);
0751: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0752: case WHITESPACE:
0753: jj_consume_token(WHITESPACE);
0754: break;
0755: default:
0756: jj_la1[10] = jj_gen;
0757: ;
0758: }
0759: break;
0760: default:
0761: jj_la1[11] = jj_gen;
0762: ;
0763: }
0764: argType = DirectiveArg();
0765: if (argType == ParserTreeConstants.JJTWORD) {
0766: if (doItNow && argPos == 0) {
0767: /* if a VM and it's the 0th arg... ok */
0768: ;
0769: } else if ((t.image.equals("#foreach") || t.image
0770: .equals("#{foreach}"))
0771: && argPos == 1) {
0772: /* if a foreach and it's the 2nd arg ok */
0773: ;
0774: } else {
0775: {
0776: if (true)
0777: throw new MacroParseException(
0778: "Invalid arg #"
0779: + argPos
0780: + " in "
0781: + (isVM ? "VM "
0782: : "directive ")
0783: + t.image,
0784: currentTemplateName, t);
0785: }
0786: }
0787: } else {
0788: if (doItNow && argPos == 0) {
0789: /* if a VM and it's the 0th arg, not ok */
0790:
0791: {
0792: if (true)
0793: throw new MacroParseException(
0794: "Invalid first arg"
0795: + " in #macro() directive - must be a"
0796: + " word token (no \' or \" surrounding)",
0797: currentTemplateName, t);
0798: }
0799: }
0800: }
0801:
0802: argPos++;
0803: }
0804: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0805: case WHITESPACE:
0806: jj_consume_token(WHITESPACE);
0807: break;
0808: default:
0809: jj_la1[12] = jj_gen;
0810: ;
0811: }
0812: jj_consume_token(RPAREN);
0813: if (directiveType == Directive.LINE) {
0814: {
0815: if (true)
0816: return jjtn000;
0817: }
0818: }
0819: ASTBlock jjtn001 = new ASTBlock(this , JJTBLOCK);
0820: boolean jjtc001 = true;
0821: jjtree.openNodeScope(jjtn001);
0822: try {
0823: label_4: while (true) {
0824: Statement();
0825: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0826: case LPAREN:
0827: case RPAREN:
0828: case ESCAPE_DIRECTIVE:
0829: case SET_DIRECTIVE:
0830: case SINGLE_LINE_COMMENT_START:
0831: case DOUBLE_ESCAPE:
0832: case ESCAPE:
0833: case TEXT:
0834: case FORMAL_COMMENT:
0835: case MULTI_LINE_COMMENT:
0836: case STRING_LITERAL:
0837: case IF_DIRECTIVE:
0838: case STOP_DIRECTIVE:
0839: case INTEGER_LITERAL:
0840: case FLOATING_POINT_LITERAL:
0841: case WORD:
0842: case BRACKETED_WORD:
0843: case IDENTIFIER:
0844: case DOT:
0845: case LCURLY:
0846: case RCURLY:
0847: ;
0848: break;
0849: default:
0850: jj_la1[13] = jj_gen;
0851: break label_4;
0852: }
0853: }
0854: } catch (Throwable jjte001) {
0855: if (jjtc001) {
0856: jjtree.clearNodeScope(jjtn001);
0857: jjtc001 = false;
0858: } else {
0859: jjtree.popNode();
0860: }
0861: if (jjte001 instanceof RuntimeException) {
0862: {
0863: if (true)
0864: throw (RuntimeException) jjte001;
0865: }
0866: }
0867: if (jjte001 instanceof ParseException) {
0868: {
0869: if (true)
0870: throw (ParseException) jjte001;
0871: }
0872: }
0873: {
0874: if (true)
0875: throw (Error) jjte001;
0876: }
0877: } finally {
0878: if (jjtc001) {
0879: jjtree.closeNodeScope(jjtn001, true);
0880: }
0881: }
0882: jj_consume_token(END);
0883: jjtree.closeNodeScope(jjtn000, true);
0884: jjtc000 = false;
0885: /*
0886: * VM : if we are processing a #macro directive, we need to
0887: * process the block. In truth, I can just register the name
0888: * and do the work later when init-ing. That would work
0889: * as long as things were always defined before use. This way
0890: * we don't have to worry about forward references and such...
0891: */
0892:
0893: if (doItNow) {
0894: Macro.processAndRegister(rsvc, t, jjtn000,
0895: currentTemplateName);
0896: }
0897:
0898: /*
0899: * VM : end
0900: */
0901:
0902: {
0903: if (true)
0904: return jjtn000;
0905: }
0906: } catch (Throwable jjte000) {
0907: if (jjtc000) {
0908: jjtree.clearNodeScope(jjtn000);
0909: jjtc000 = false;
0910: } else {
0911: jjtree.popNode();
0912: }
0913: if (jjte000 instanceof RuntimeException) {
0914: {
0915: if (true)
0916: throw (RuntimeException) jjte000;
0917: }
0918: }
0919: if (jjte000 instanceof ParseException) {
0920: {
0921: if (true)
0922: throw (ParseException) jjte000;
0923: }
0924: }
0925: {
0926: if (true)
0927: throw (Error) jjte000;
0928: }
0929: } finally {
0930: if (jjtc000) {
0931: jjtree.closeNodeScope(jjtn000, true);
0932: }
0933: }
0934: throw new Error("Missing return statement in function");
0935: }
0936:
0937: /**
0938: * for creating a map in a #set
0939: *
0940: * #set($foo = {$foo : $bar, $blargh : $thingy})
0941: */
0942: final public void Map() throws ParseException {
0943: /*@bgen(jjtree) Map */
0944: ASTMap jjtn000 = new ASTMap(this , JJTMAP);
0945: boolean jjtc000 = true;
0946: jjtree.openNodeScope(jjtn000);
0947: try {
0948: jj_consume_token(LEFT_CURLEY);
0949: if (jj_2_5(2)) {
0950: Parameter();
0951: jj_consume_token(COLON);
0952: Parameter();
0953: label_5: while (true) {
0954: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0955: case COMMA:
0956: ;
0957: break;
0958: default:
0959: jj_la1[14] = jj_gen;
0960: break label_5;
0961: }
0962: jj_consume_token(COMMA);
0963: Parameter();
0964: jj_consume_token(COLON);
0965: Parameter();
0966: }
0967: } else {
0968: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0969: case WHITESPACE:
0970: jj_consume_token(WHITESPACE);
0971: break;
0972: default:
0973: jj_la1[15] = jj_gen;
0974: ;
0975: }
0976: }
0977: jj_consume_token(RIGHT_CURLEY);
0978: } catch (Throwable jjte000) {
0979: if (jjtc000) {
0980: jjtree.clearNodeScope(jjtn000);
0981: jjtc000 = false;
0982: } else {
0983: jjtree.popNode();
0984: }
0985: if (jjte000 instanceof RuntimeException) {
0986: {
0987: if (true)
0988: throw (RuntimeException) jjte000;
0989: }
0990: }
0991: if (jjte000 instanceof ParseException) {
0992: {
0993: if (true)
0994: throw (ParseException) jjte000;
0995: }
0996: }
0997: {
0998: if (true)
0999: throw (Error) jjte000;
1000: }
1001: } finally {
1002: if (jjtc000) {
1003: jjtree.closeNodeScope(jjtn000, true);
1004: }
1005: }
1006: }
1007:
1008: final public void ObjectArray() throws ParseException {
1009: /*@bgen(jjtree) ObjectArray */
1010: ASTObjectArray jjtn000 = new ASTObjectArray(this ,
1011: JJTOBJECTARRAY);
1012: boolean jjtc000 = true;
1013: jjtree.openNodeScope(jjtn000);
1014: try {
1015: jj_consume_token(LBRACKET);
1016: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1017: case LBRACKET:
1018: case LEFT_CURLEY:
1019: case WHITESPACE:
1020: case STRING_LITERAL:
1021: case TRUE:
1022: case FALSE:
1023: case INTEGER_LITERAL:
1024: case FLOATING_POINT_LITERAL:
1025: case IDENTIFIER:
1026: case LCURLY:
1027: Parameter();
1028: label_6: while (true) {
1029: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1030: case COMMA:
1031: ;
1032: break;
1033: default:
1034: jj_la1[16] = jj_gen;
1035: break label_6;
1036: }
1037: jj_consume_token(COMMA);
1038: Parameter();
1039: }
1040: break;
1041: default:
1042: jj_la1[17] = jj_gen;
1043: ;
1044: }
1045: jj_consume_token(RBRACKET);
1046: } catch (Throwable jjte000) {
1047: if (jjtc000) {
1048: jjtree.clearNodeScope(jjtn000);
1049: jjtc000 = false;
1050: } else {
1051: jjtree.popNode();
1052: }
1053: if (jjte000 instanceof RuntimeException) {
1054: {
1055: if (true)
1056: throw (RuntimeException) jjte000;
1057: }
1058: }
1059: if (jjte000 instanceof ParseException) {
1060: {
1061: if (true)
1062: throw (ParseException) jjte000;
1063: }
1064: }
1065: {
1066: if (true)
1067: throw (Error) jjte000;
1068: }
1069: } finally {
1070: if (jjtc000) {
1071: jjtree.closeNodeScope(jjtn000, true);
1072: }
1073: }
1074: }
1075:
1076: /**
1077: * supports the [n..m] vector generator for use in
1078: * the #foreach() to generate measured ranges w/o
1079: * needing explicit support from the app/servlet
1080: */
1081: final public void IntegerRange() throws ParseException {
1082: /*@bgen(jjtree) IntegerRange */
1083: ASTIntegerRange jjtn000 = new ASTIntegerRange(this ,
1084: JJTINTEGERRANGE);
1085: boolean jjtc000 = true;
1086: jjtree.openNodeScope(jjtn000);
1087: try {
1088: jj_consume_token(LBRACKET);
1089: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1090: case WHITESPACE:
1091: jj_consume_token(WHITESPACE);
1092: break;
1093: default:
1094: jj_la1[18] = jj_gen;
1095: ;
1096: }
1097: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1098: case IDENTIFIER:
1099: case LCURLY:
1100: Reference();
1101: break;
1102: case INTEGER_LITERAL:
1103: IntegerLiteral();
1104: break;
1105: default:
1106: jj_la1[19] = jj_gen;
1107: jj_consume_token(-1);
1108: throw new ParseException();
1109: }
1110: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1111: case WHITESPACE:
1112: jj_consume_token(WHITESPACE);
1113: break;
1114: default:
1115: jj_la1[20] = jj_gen;
1116: ;
1117: }
1118: jj_consume_token(DOUBLEDOT);
1119: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1120: case WHITESPACE:
1121: jj_consume_token(WHITESPACE);
1122: break;
1123: default:
1124: jj_la1[21] = jj_gen;
1125: ;
1126: }
1127: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1128: case IDENTIFIER:
1129: case LCURLY:
1130: Reference();
1131: break;
1132: case INTEGER_LITERAL:
1133: IntegerLiteral();
1134: break;
1135: default:
1136: jj_la1[22] = jj_gen;
1137: jj_consume_token(-1);
1138: throw new ParseException();
1139: }
1140: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1141: case WHITESPACE:
1142: jj_consume_token(WHITESPACE);
1143: break;
1144: default:
1145: jj_la1[23] = jj_gen;
1146: ;
1147: }
1148: jj_consume_token(RBRACKET);
1149: } catch (Throwable jjte000) {
1150: if (jjtc000) {
1151: jjtree.clearNodeScope(jjtn000);
1152: jjtc000 = false;
1153: } else {
1154: jjtree.popNode();
1155: }
1156: if (jjte000 instanceof RuntimeException) {
1157: {
1158: if (true)
1159: throw (RuntimeException) jjte000;
1160: }
1161: }
1162: if (jjte000 instanceof ParseException) {
1163: {
1164: if (true)
1165: throw (ParseException) jjte000;
1166: }
1167: }
1168: {
1169: if (true)
1170: throw (Error) jjte000;
1171: }
1172: } finally {
1173: if (jjtc000) {
1174: jjtree.closeNodeScope(jjtn000, true);
1175: }
1176: }
1177: }
1178:
1179: /**
1180: * This method has yet to be fully implemented
1181: * but will allow arbitrarily nested method
1182: * calls
1183: */
1184: final public void Parameter() throws ParseException {
1185: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1186: case WHITESPACE:
1187: jj_consume_token(WHITESPACE);
1188: break;
1189: default:
1190: jj_la1[24] = jj_gen;
1191: ;
1192: }
1193: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1194: case STRING_LITERAL:
1195: StringLiteral();
1196: break;
1197: case INTEGER_LITERAL:
1198: IntegerLiteral();
1199: break;
1200: default:
1201: jj_la1[25] = jj_gen;
1202: if (jj_2_6(2147483647)) {
1203: IntegerRange();
1204: } else {
1205: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1206: case LEFT_CURLEY:
1207: Map();
1208: break;
1209: case LBRACKET:
1210: ObjectArray();
1211: break;
1212: case TRUE:
1213: True();
1214: break;
1215: case FALSE:
1216: False();
1217: break;
1218: case IDENTIFIER:
1219: case LCURLY:
1220: Reference();
1221: break;
1222: case FLOATING_POINT_LITERAL:
1223: FloatingPointLiteral();
1224: break;
1225: default:
1226: jj_la1[26] = jj_gen;
1227: jj_consume_token(-1);
1228: throw new ParseException();
1229: }
1230: }
1231: }
1232: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1233: case WHITESPACE:
1234: jj_consume_token(WHITESPACE);
1235: break;
1236: default:
1237: jj_la1[27] = jj_gen;
1238: ;
1239: }
1240: }
1241:
1242: /**
1243: * This method has yet to be fully implemented
1244: * but will allow arbitrarily nested method
1245: * calls
1246: */
1247: final public void Method() throws ParseException {
1248: /*@bgen(jjtree) Method */
1249: ASTMethod jjtn000 = new ASTMethod(this , JJTMETHOD);
1250: boolean jjtc000 = true;
1251: jjtree.openNodeScope(jjtn000);
1252: try {
1253: Identifier();
1254: jj_consume_token(LPAREN);
1255: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1256: case LBRACKET:
1257: case LEFT_CURLEY:
1258: case WHITESPACE:
1259: case STRING_LITERAL:
1260: case TRUE:
1261: case FALSE:
1262: case INTEGER_LITERAL:
1263: case FLOATING_POINT_LITERAL:
1264: case IDENTIFIER:
1265: case LCURLY:
1266: Parameter();
1267: label_7: while (true) {
1268: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1269: case COMMA:
1270: ;
1271: break;
1272: default:
1273: jj_la1[28] = jj_gen;
1274: break label_7;
1275: }
1276: jj_consume_token(COMMA);
1277: Parameter();
1278: }
1279: break;
1280: default:
1281: jj_la1[29] = jj_gen;
1282: ;
1283: }
1284: jj_consume_token(REFMOD2_RPAREN);
1285: } catch (Throwable jjte000) {
1286: if (jjtc000) {
1287: jjtree.clearNodeScope(jjtn000);
1288: jjtc000 = false;
1289: } else {
1290: jjtree.popNode();
1291: }
1292: if (jjte000 instanceof RuntimeException) {
1293: {
1294: if (true)
1295: throw (RuntimeException) jjte000;
1296: }
1297: }
1298: if (jjte000 instanceof ParseException) {
1299: {
1300: if (true)
1301: throw (ParseException) jjte000;
1302: }
1303: }
1304: {
1305: if (true)
1306: throw (Error) jjte000;
1307: }
1308: } finally {
1309: if (jjtc000) {
1310: jjtree.closeNodeScope(jjtn000, true);
1311: }
1312: }
1313: }
1314:
1315: final public void Reference() throws ParseException {
1316: /*@bgen(jjtree) Reference */
1317: ASTReference jjtn000 = new ASTReference(this , JJTREFERENCE);
1318: boolean jjtc000 = true;
1319: jjtree.openNodeScope(jjtn000);
1320: try {
1321: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1322: case IDENTIFIER:
1323: jj_consume_token(IDENTIFIER);
1324: label_8: while (true) {
1325: if (jj_2_7(2)) {
1326: ;
1327: } else {
1328: break label_8;
1329: }
1330: jj_consume_token(DOT);
1331: if (jj_2_8(3)) {
1332: Method();
1333: } else {
1334: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1335: case IDENTIFIER:
1336: Identifier();
1337: break;
1338: default:
1339: jj_la1[30] = jj_gen;
1340: jj_consume_token(-1);
1341: throw new ParseException();
1342: }
1343: }
1344: }
1345: break;
1346: case LCURLY:
1347: jj_consume_token(LCURLY);
1348: jj_consume_token(IDENTIFIER);
1349: label_9: while (true) {
1350: if (jj_2_9(2)) {
1351: ;
1352: } else {
1353: break label_9;
1354: }
1355: jj_consume_token(DOT);
1356: if (jj_2_10(3)) {
1357: Method();
1358: } else {
1359: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1360: case IDENTIFIER:
1361: Identifier();
1362: break;
1363: default:
1364: jj_la1[31] = jj_gen;
1365: jj_consume_token(-1);
1366: throw new ParseException();
1367: }
1368: }
1369: }
1370: jj_consume_token(RCURLY);
1371: break;
1372: default:
1373: jj_la1[32] = jj_gen;
1374: jj_consume_token(-1);
1375: throw new ParseException();
1376: }
1377: } catch (Throwable jjte000) {
1378: if (jjtc000) {
1379: jjtree.clearNodeScope(jjtn000);
1380: jjtc000 = false;
1381: } else {
1382: jjtree.popNode();
1383: }
1384: if (jjte000 instanceof RuntimeException) {
1385: {
1386: if (true)
1387: throw (RuntimeException) jjte000;
1388: }
1389: }
1390: if (jjte000 instanceof ParseException) {
1391: {
1392: if (true)
1393: throw (ParseException) jjte000;
1394: }
1395: }
1396: {
1397: if (true)
1398: throw (Error) jjte000;
1399: }
1400: } finally {
1401: if (jjtc000) {
1402: jjtree.closeNodeScope(jjtn000, true);
1403: }
1404: }
1405: }
1406:
1407: final public void True() throws ParseException {
1408: /*@bgen(jjtree) True */
1409: ASTTrue jjtn000 = new ASTTrue(this , JJTTRUE);
1410: boolean jjtc000 = true;
1411: jjtree.openNodeScope(jjtn000);
1412: try {
1413: jj_consume_token(TRUE);
1414: } finally {
1415: if (jjtc000) {
1416: jjtree.closeNodeScope(jjtn000, true);
1417: }
1418: }
1419: }
1420:
1421: final public void False() throws ParseException {
1422: /*@bgen(jjtree) False */
1423: ASTFalse jjtn000 = new ASTFalse(this , JJTFALSE);
1424: boolean jjtc000 = true;
1425: jjtree.openNodeScope(jjtn000);
1426: try {
1427: jj_consume_token(FALSE);
1428: } finally {
1429: if (jjtc000) {
1430: jjtree.closeNodeScope(jjtn000, true);
1431: }
1432: }
1433: }
1434:
1435: /**
1436: * This method is responsible for allowing
1437: * all non-grammar text to pass through
1438: * unscathed.
1439: */
1440: final public void Text() throws ParseException {
1441: /*@bgen(jjtree) Text */
1442: ASTText jjtn000 = new ASTText(this , JJTTEXT);
1443: boolean jjtc000 = true;
1444: jjtree.openNodeScope(jjtn000);
1445: try {
1446: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1447: case TEXT:
1448: jj_consume_token(TEXT);
1449: break;
1450: case DOT:
1451: jj_consume_token(DOT);
1452: break;
1453: case RPAREN:
1454: jj_consume_token(RPAREN);
1455: break;
1456: case LPAREN:
1457: jj_consume_token(LPAREN);
1458: break;
1459: case INTEGER_LITERAL:
1460: jj_consume_token(INTEGER_LITERAL);
1461: break;
1462: case FLOATING_POINT_LITERAL:
1463: jj_consume_token(FLOATING_POINT_LITERAL);
1464: break;
1465: case STRING_LITERAL:
1466: jj_consume_token(STRING_LITERAL);
1467: break;
1468: case ESCAPE:
1469: jj_consume_token(ESCAPE);
1470: break;
1471: case LCURLY:
1472: jj_consume_token(LCURLY);
1473: break;
1474: case RCURLY:
1475: jj_consume_token(RCURLY);
1476: break;
1477: default:
1478: jj_la1[33] = jj_gen;
1479: jj_consume_token(-1);
1480: throw new ParseException();
1481: }
1482: } finally {
1483: if (jjtc000) {
1484: jjtree.closeNodeScope(jjtn000, true);
1485: }
1486: }
1487: }
1488:
1489: /* -----------------------------------------------------------------------
1490: *
1491: * Defined Directive Syntax
1492: *
1493: * ----------------------------------------------------------------------*/
1494: final public void IfStatement() throws ParseException {
1495: /*@bgen(jjtree) IfStatement */
1496: ASTIfStatement jjtn000 = new ASTIfStatement(this ,
1497: JJTIFSTATEMENT);
1498: boolean jjtc000 = true;
1499: jjtree.openNodeScope(jjtn000);
1500: try {
1501: jj_consume_token(IF_DIRECTIVE);
1502: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1503: case WHITESPACE:
1504: jj_consume_token(WHITESPACE);
1505: break;
1506: default:
1507: jj_la1[34] = jj_gen;
1508: ;
1509: }
1510: jj_consume_token(LPAREN);
1511: Expression();
1512: jj_consume_token(RPAREN);
1513: ASTBlock jjtn001 = new ASTBlock(this , JJTBLOCK);
1514: boolean jjtc001 = true;
1515: jjtree.openNodeScope(jjtn001);
1516: try {
1517: label_10: while (true) {
1518: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1519: case LPAREN:
1520: case RPAREN:
1521: case ESCAPE_DIRECTIVE:
1522: case SET_DIRECTIVE:
1523: case SINGLE_LINE_COMMENT_START:
1524: case DOUBLE_ESCAPE:
1525: case ESCAPE:
1526: case TEXT:
1527: case FORMAL_COMMENT:
1528: case MULTI_LINE_COMMENT:
1529: case STRING_LITERAL:
1530: case IF_DIRECTIVE:
1531: case STOP_DIRECTIVE:
1532: case INTEGER_LITERAL:
1533: case FLOATING_POINT_LITERAL:
1534: case WORD:
1535: case BRACKETED_WORD:
1536: case IDENTIFIER:
1537: case DOT:
1538: case LCURLY:
1539: case RCURLY:
1540: ;
1541: break;
1542: default:
1543: jj_la1[35] = jj_gen;
1544: break label_10;
1545: }
1546: Statement();
1547: }
1548: } catch (Throwable jjte001) {
1549: if (jjtc001) {
1550: jjtree.clearNodeScope(jjtn001);
1551: jjtc001 = false;
1552: } else {
1553: jjtree.popNode();
1554: }
1555: if (jjte001 instanceof RuntimeException) {
1556: {
1557: if (true)
1558: throw (RuntimeException) jjte001;
1559: }
1560: }
1561: if (jjte001 instanceof ParseException) {
1562: {
1563: if (true)
1564: throw (ParseException) jjte001;
1565: }
1566: }
1567: {
1568: if (true)
1569: throw (Error) jjte001;
1570: }
1571: } finally {
1572: if (jjtc001) {
1573: jjtree.closeNodeScope(jjtn001, true);
1574: }
1575: }
1576: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1577: case ELSEIF_DIRECTIVE:
1578: label_11: while (true) {
1579: ElseIfStatement();
1580: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1581: case ELSEIF_DIRECTIVE:
1582: ;
1583: break;
1584: default:
1585: jj_la1[36] = jj_gen;
1586: break label_11;
1587: }
1588: }
1589: break;
1590: default:
1591: jj_la1[37] = jj_gen;
1592: ;
1593: }
1594: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1595: case ELSE_DIRECTIVE:
1596: ElseStatement();
1597: break;
1598: default:
1599: jj_la1[38] = jj_gen;
1600: ;
1601: }
1602: jj_consume_token(END);
1603: } catch (Throwable jjte000) {
1604: if (jjtc000) {
1605: jjtree.clearNodeScope(jjtn000);
1606: jjtc000 = false;
1607: } else {
1608: jjtree.popNode();
1609: }
1610: if (jjte000 instanceof RuntimeException) {
1611: {
1612: if (true)
1613: throw (RuntimeException) jjte000;
1614: }
1615: }
1616: if (jjte000 instanceof ParseException) {
1617: {
1618: if (true)
1619: throw (ParseException) jjte000;
1620: }
1621: }
1622: {
1623: if (true)
1624: throw (Error) jjte000;
1625: }
1626: } finally {
1627: if (jjtc000) {
1628: jjtree.closeNodeScope(jjtn000, true);
1629: }
1630: }
1631: }
1632:
1633: final public void ElseStatement() throws ParseException {
1634: /*@bgen(jjtree) ElseStatement */
1635: ASTElseStatement jjtn000 = new ASTElseStatement(this ,
1636: JJTELSESTATEMENT);
1637: boolean jjtc000 = true;
1638: jjtree.openNodeScope(jjtn000);
1639: try {
1640: jj_consume_token(ELSE_DIRECTIVE);
1641: ASTBlock jjtn001 = new ASTBlock(this , JJTBLOCK);
1642: boolean jjtc001 = true;
1643: jjtree.openNodeScope(jjtn001);
1644: try {
1645: label_12: while (true) {
1646: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1647: case LPAREN:
1648: case RPAREN:
1649: case ESCAPE_DIRECTIVE:
1650: case SET_DIRECTIVE:
1651: case SINGLE_LINE_COMMENT_START:
1652: case DOUBLE_ESCAPE:
1653: case ESCAPE:
1654: case TEXT:
1655: case FORMAL_COMMENT:
1656: case MULTI_LINE_COMMENT:
1657: case STRING_LITERAL:
1658: case IF_DIRECTIVE:
1659: case STOP_DIRECTIVE:
1660: case INTEGER_LITERAL:
1661: case FLOATING_POINT_LITERAL:
1662: case WORD:
1663: case BRACKETED_WORD:
1664: case IDENTIFIER:
1665: case DOT:
1666: case LCURLY:
1667: case RCURLY:
1668: ;
1669: break;
1670: default:
1671: jj_la1[39] = jj_gen;
1672: break label_12;
1673: }
1674: Statement();
1675: }
1676: } catch (Throwable jjte001) {
1677: if (jjtc001) {
1678: jjtree.clearNodeScope(jjtn001);
1679: jjtc001 = false;
1680: } else {
1681: jjtree.popNode();
1682: }
1683: if (jjte001 instanceof RuntimeException) {
1684: {
1685: if (true)
1686: throw (RuntimeException) jjte001;
1687: }
1688: }
1689: if (jjte001 instanceof ParseException) {
1690: {
1691: if (true)
1692: throw (ParseException) jjte001;
1693: }
1694: }
1695: {
1696: if (true)
1697: throw (Error) jjte001;
1698: }
1699: } finally {
1700: if (jjtc001) {
1701: jjtree.closeNodeScope(jjtn001, true);
1702: }
1703: }
1704: } catch (Throwable jjte000) {
1705: if (jjtc000) {
1706: jjtree.clearNodeScope(jjtn000);
1707: jjtc000 = false;
1708: } else {
1709: jjtree.popNode();
1710: }
1711: if (jjte000 instanceof RuntimeException) {
1712: {
1713: if (true)
1714: throw (RuntimeException) jjte000;
1715: }
1716: }
1717: if (jjte000 instanceof ParseException) {
1718: {
1719: if (true)
1720: throw (ParseException) jjte000;
1721: }
1722: }
1723: {
1724: if (true)
1725: throw (Error) jjte000;
1726: }
1727: } finally {
1728: if (jjtc000) {
1729: jjtree.closeNodeScope(jjtn000, true);
1730: }
1731: }
1732: }
1733:
1734: final public void ElseIfStatement() throws ParseException {
1735: /*@bgen(jjtree) ElseIfStatement */
1736: ASTElseIfStatement jjtn000 = new ASTElseIfStatement(this ,
1737: JJTELSEIFSTATEMENT);
1738: boolean jjtc000 = true;
1739: jjtree.openNodeScope(jjtn000);
1740: try {
1741: jj_consume_token(ELSEIF_DIRECTIVE);
1742: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1743: case WHITESPACE:
1744: jj_consume_token(WHITESPACE);
1745: break;
1746: default:
1747: jj_la1[40] = jj_gen;
1748: ;
1749: }
1750: jj_consume_token(LPAREN);
1751: Expression();
1752: jj_consume_token(RPAREN);
1753: ASTBlock jjtn001 = new ASTBlock(this , JJTBLOCK);
1754: boolean jjtc001 = true;
1755: jjtree.openNodeScope(jjtn001);
1756: try {
1757: label_13: while (true) {
1758: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1759: case LPAREN:
1760: case RPAREN:
1761: case ESCAPE_DIRECTIVE:
1762: case SET_DIRECTIVE:
1763: case SINGLE_LINE_COMMENT_START:
1764: case DOUBLE_ESCAPE:
1765: case ESCAPE:
1766: case TEXT:
1767: case FORMAL_COMMENT:
1768: case MULTI_LINE_COMMENT:
1769: case STRING_LITERAL:
1770: case IF_DIRECTIVE:
1771: case STOP_DIRECTIVE:
1772: case INTEGER_LITERAL:
1773: case FLOATING_POINT_LITERAL:
1774: case WORD:
1775: case BRACKETED_WORD:
1776: case IDENTIFIER:
1777: case DOT:
1778: case LCURLY:
1779: case RCURLY:
1780: ;
1781: break;
1782: default:
1783: jj_la1[41] = jj_gen;
1784: break label_13;
1785: }
1786: Statement();
1787: }
1788: } catch (Throwable jjte001) {
1789: if (jjtc001) {
1790: jjtree.clearNodeScope(jjtn001);
1791: jjtc001 = false;
1792: } else {
1793: jjtree.popNode();
1794: }
1795: if (jjte001 instanceof RuntimeException) {
1796: {
1797: if (true)
1798: throw (RuntimeException) jjte001;
1799: }
1800: }
1801: if (jjte001 instanceof ParseException) {
1802: {
1803: if (true)
1804: throw (ParseException) jjte001;
1805: }
1806: }
1807: {
1808: if (true)
1809: throw (Error) jjte001;
1810: }
1811: } finally {
1812: if (jjtc001) {
1813: jjtree.closeNodeScope(jjtn001, true);
1814: }
1815: }
1816: } catch (Throwable jjte000) {
1817: if (jjtc000) {
1818: jjtree.clearNodeScope(jjtn000);
1819: jjtc000 = false;
1820: } else {
1821: jjtree.popNode();
1822: }
1823: if (jjte000 instanceof RuntimeException) {
1824: {
1825: if (true)
1826: throw (RuntimeException) jjte000;
1827: }
1828: }
1829: if (jjte000 instanceof ParseException) {
1830: {
1831: if (true)
1832: throw (ParseException) jjte000;
1833: }
1834: }
1835: {
1836: if (true)
1837: throw (Error) jjte000;
1838: }
1839: } finally {
1840: if (jjtc000) {
1841: jjtree.closeNodeScope(jjtn000, true);
1842: }
1843: }
1844: }
1845:
1846: /**
1847: * Currently support both types of set :
1848: * #set( expr )
1849: * #set expr
1850: */
1851: final public void SetDirective() throws ParseException {
1852: /*@bgen(jjtree) SetDirective */
1853: ASTSetDirective jjtn000 = new ASTSetDirective(this ,
1854: JJTSETDIRECTIVE);
1855: boolean jjtc000 = true;
1856: jjtree.openNodeScope(jjtn000);
1857: try {
1858: jj_consume_token(SET_DIRECTIVE);
1859: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1860: case WHITESPACE:
1861: jj_consume_token(WHITESPACE);
1862: break;
1863: default:
1864: jj_la1[42] = jj_gen;
1865: ;
1866: }
1867: Reference();
1868: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1869: case WHITESPACE:
1870: jj_consume_token(WHITESPACE);
1871: break;
1872: default:
1873: jj_la1[43] = jj_gen;
1874: ;
1875: }
1876: jj_consume_token(EQUALS);
1877: Expression();
1878: jj_consume_token(RPAREN);
1879: /*
1880: * ensure that inSet is false. Leads to some amusing bugs...
1881: */
1882:
1883: token_source.inSet = false;
1884: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1885: case NEWLINE:
1886: jj_consume_token(NEWLINE);
1887: break;
1888: default:
1889: jj_la1[44] = jj_gen;
1890: ;
1891: }
1892: } catch (Throwable jjte000) {
1893: if (jjtc000) {
1894: jjtree.clearNodeScope(jjtn000);
1895: jjtc000 = false;
1896: } else {
1897: jjtree.popNode();
1898: }
1899: if (jjte000 instanceof RuntimeException) {
1900: {
1901: if (true)
1902: throw (RuntimeException) jjte000;
1903: }
1904: }
1905: if (jjte000 instanceof ParseException) {
1906: {
1907: if (true)
1908: throw (ParseException) jjte000;
1909: }
1910: }
1911: {
1912: if (true)
1913: throw (Error) jjte000;
1914: }
1915: } finally {
1916: if (jjtc000) {
1917: jjtree.closeNodeScope(jjtn000, true);
1918: }
1919: }
1920: }
1921:
1922: /**
1923: * This method corresponds to the #stop
1924: * directive which just simulates and EOF
1925: * so that parsing stops. The #stop directive
1926: * is useful for end-user debugging
1927: * purposes.
1928: */
1929: final public void StopStatement() throws ParseException {
1930: /*@bgen(jjtree) #Stop( 0) */
1931: ASTStop jjtn000 = new ASTStop(this , JJTSTOP);
1932: boolean jjtc000 = true;
1933: jjtree.openNodeScope(jjtn000);
1934: try {
1935: jj_consume_token(STOP_DIRECTIVE);
1936: } finally {
1937: if (jjtc000) {
1938: jjtree.closeNodeScope(jjtn000, 0);
1939: }
1940: }
1941: }
1942:
1943: /* -----------------------------------------------------------------------
1944: *
1945: * Expression Syntax
1946: *
1947: * ----------------------------------------------------------------------*/
1948: final public void Expression() throws ParseException {
1949: /*@bgen(jjtree) Expression */
1950: ASTExpression jjtn000 = new ASTExpression(this , JJTEXPRESSION);
1951: boolean jjtc000 = true;
1952: jjtree.openNodeScope(jjtn000);
1953: try {
1954: ConditionalOrExpression();
1955: } catch (Throwable jjte000) {
1956: if (jjtc000) {
1957: jjtree.clearNodeScope(jjtn000);
1958: jjtc000 = false;
1959: } else {
1960: jjtree.popNode();
1961: }
1962: if (jjte000 instanceof RuntimeException) {
1963: {
1964: if (true)
1965: throw (RuntimeException) jjte000;
1966: }
1967: }
1968: if (jjte000 instanceof ParseException) {
1969: {
1970: if (true)
1971: throw (ParseException) jjte000;
1972: }
1973: }
1974: {
1975: if (true)
1976: throw (Error) jjte000;
1977: }
1978: } finally {
1979: if (jjtc000) {
1980: jjtree.closeNodeScope(jjtn000, true);
1981: }
1982: }
1983: }
1984:
1985: final public void Assignment() throws ParseException {
1986: /*@bgen(jjtree) #Assignment( 2) */
1987: ASTAssignment jjtn000 = new ASTAssignment(this , JJTASSIGNMENT);
1988: boolean jjtc000 = true;
1989: jjtree.openNodeScope(jjtn000);
1990: try {
1991: PrimaryExpression();
1992: jj_consume_token(EQUALS);
1993: Expression();
1994: } catch (Throwable jjte000) {
1995: if (jjtc000) {
1996: jjtree.clearNodeScope(jjtn000);
1997: jjtc000 = false;
1998: } else {
1999: jjtree.popNode();
2000: }
2001: if (jjte000 instanceof RuntimeException) {
2002: {
2003: if (true)
2004: throw (RuntimeException) jjte000;
2005: }
2006: }
2007: if (jjte000 instanceof ParseException) {
2008: {
2009: if (true)
2010: throw (ParseException) jjte000;
2011: }
2012: }
2013: {
2014: if (true)
2015: throw (Error) jjte000;
2016: }
2017: } finally {
2018: if (jjtc000) {
2019: jjtree.closeNodeScope(jjtn000, 2);
2020: }
2021: }
2022: }
2023:
2024: final public void ConditionalOrExpression() throws ParseException {
2025: ConditionalAndExpression();
2026: label_14: while (true) {
2027: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2028: case LOGICAL_OR:
2029: ;
2030: break;
2031: default:
2032: jj_la1[45] = jj_gen;
2033: break label_14;
2034: }
2035: jj_consume_token(LOGICAL_OR);
2036: ASTOrNode jjtn001 = new ASTOrNode(this , JJTORNODE);
2037: boolean jjtc001 = true;
2038: jjtree.openNodeScope(jjtn001);
2039: try {
2040: ConditionalAndExpression();
2041: } catch (Throwable jjte001) {
2042: if (jjtc001) {
2043: jjtree.clearNodeScope(jjtn001);
2044: jjtc001 = false;
2045: } else {
2046: jjtree.popNode();
2047: }
2048: if (jjte001 instanceof RuntimeException) {
2049: {
2050: if (true)
2051: throw (RuntimeException) jjte001;
2052: }
2053: }
2054: if (jjte001 instanceof ParseException) {
2055: {
2056: if (true)
2057: throw (ParseException) jjte001;
2058: }
2059: }
2060: {
2061: if (true)
2062: throw (Error) jjte001;
2063: }
2064: } finally {
2065: if (jjtc001) {
2066: jjtree.closeNodeScope(jjtn001, 2);
2067: }
2068: }
2069: }
2070: }
2071:
2072: final public void ConditionalAndExpression() throws ParseException {
2073: EqualityExpression();
2074: label_15: while (true) {
2075: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2076: case LOGICAL_AND:
2077: ;
2078: break;
2079: default:
2080: jj_la1[46] = jj_gen;
2081: break label_15;
2082: }
2083: jj_consume_token(LOGICAL_AND);
2084: ASTAndNode jjtn001 = new ASTAndNode(this , JJTANDNODE);
2085: boolean jjtc001 = true;
2086: jjtree.openNodeScope(jjtn001);
2087: try {
2088: EqualityExpression();
2089: } catch (Throwable jjte001) {
2090: if (jjtc001) {
2091: jjtree.clearNodeScope(jjtn001);
2092: jjtc001 = false;
2093: } else {
2094: jjtree.popNode();
2095: }
2096: if (jjte001 instanceof RuntimeException) {
2097: {
2098: if (true)
2099: throw (RuntimeException) jjte001;
2100: }
2101: }
2102: if (jjte001 instanceof ParseException) {
2103: {
2104: if (true)
2105: throw (ParseException) jjte001;
2106: }
2107: }
2108: {
2109: if (true)
2110: throw (Error) jjte001;
2111: }
2112: } finally {
2113: if (jjtc001) {
2114: jjtree.closeNodeScope(jjtn001, 2);
2115: }
2116: }
2117: }
2118: }
2119:
2120: final public void EqualityExpression() throws ParseException {
2121: RelationalExpression();
2122: label_16: while (true) {
2123: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2124: case LOGICAL_EQUALS:
2125: case LOGICAL_NOT_EQUALS:
2126: ;
2127: break;
2128: default:
2129: jj_la1[47] = jj_gen;
2130: break label_16;
2131: }
2132: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2133: case LOGICAL_EQUALS:
2134: jj_consume_token(LOGICAL_EQUALS);
2135: ASTEQNode jjtn001 = new ASTEQNode(this , JJTEQNODE);
2136: boolean jjtc001 = true;
2137: jjtree.openNodeScope(jjtn001);
2138: try {
2139: RelationalExpression();
2140: } catch (Throwable jjte001) {
2141: if (jjtc001) {
2142: jjtree.clearNodeScope(jjtn001);
2143: jjtc001 = false;
2144: } else {
2145: jjtree.popNode();
2146: }
2147: if (jjte001 instanceof RuntimeException) {
2148: {
2149: if (true)
2150: throw (RuntimeException) jjte001;
2151: }
2152: }
2153: if (jjte001 instanceof ParseException) {
2154: {
2155: if (true)
2156: throw (ParseException) jjte001;
2157: }
2158: }
2159: {
2160: if (true)
2161: throw (Error) jjte001;
2162: }
2163: } finally {
2164: if (jjtc001) {
2165: jjtree.closeNodeScope(jjtn001, 2);
2166: }
2167: }
2168: break;
2169: case LOGICAL_NOT_EQUALS:
2170: jj_consume_token(LOGICAL_NOT_EQUALS);
2171: ASTNENode jjtn002 = new ASTNENode(this , JJTNENODE);
2172: boolean jjtc002 = true;
2173: jjtree.openNodeScope(jjtn002);
2174: try {
2175: RelationalExpression();
2176: } catch (Throwable jjte002) {
2177: if (jjtc002) {
2178: jjtree.clearNodeScope(jjtn002);
2179: jjtc002 = false;
2180: } else {
2181: jjtree.popNode();
2182: }
2183: if (jjte002 instanceof RuntimeException) {
2184: {
2185: if (true)
2186: throw (RuntimeException) jjte002;
2187: }
2188: }
2189: if (jjte002 instanceof ParseException) {
2190: {
2191: if (true)
2192: throw (ParseException) jjte002;
2193: }
2194: }
2195: {
2196: if (true)
2197: throw (Error) jjte002;
2198: }
2199: } finally {
2200: if (jjtc002) {
2201: jjtree.closeNodeScope(jjtn002, 2);
2202: }
2203: }
2204: break;
2205: default:
2206: jj_la1[48] = jj_gen;
2207: jj_consume_token(-1);
2208: throw new ParseException();
2209: }
2210: }
2211: }
2212:
2213: final public void RelationalExpression() throws ParseException {
2214: AdditiveExpression();
2215: label_17: while (true) {
2216: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2217: case LOGICAL_LT:
2218: case LOGICAL_LE:
2219: case LOGICAL_GT:
2220: case LOGICAL_GE:
2221: ;
2222: break;
2223: default:
2224: jj_la1[49] = jj_gen;
2225: break label_17;
2226: }
2227: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2228: case LOGICAL_LT:
2229: jj_consume_token(LOGICAL_LT);
2230: ASTLTNode jjtn001 = new ASTLTNode(this , JJTLTNODE);
2231: boolean jjtc001 = true;
2232: jjtree.openNodeScope(jjtn001);
2233: try {
2234: AdditiveExpression();
2235: } catch (Throwable jjte001) {
2236: if (jjtc001) {
2237: jjtree.clearNodeScope(jjtn001);
2238: jjtc001 = false;
2239: } else {
2240: jjtree.popNode();
2241: }
2242: if (jjte001 instanceof RuntimeException) {
2243: {
2244: if (true)
2245: throw (RuntimeException) jjte001;
2246: }
2247: }
2248: if (jjte001 instanceof ParseException) {
2249: {
2250: if (true)
2251: throw (ParseException) jjte001;
2252: }
2253: }
2254: {
2255: if (true)
2256: throw (Error) jjte001;
2257: }
2258: } finally {
2259: if (jjtc001) {
2260: jjtree.closeNodeScope(jjtn001, 2);
2261: }
2262: }
2263: break;
2264: case LOGICAL_GT:
2265: jj_consume_token(LOGICAL_GT);
2266: ASTGTNode jjtn002 = new ASTGTNode(this , JJTGTNODE);
2267: boolean jjtc002 = true;
2268: jjtree.openNodeScope(jjtn002);
2269: try {
2270: AdditiveExpression();
2271: } catch (Throwable jjte002) {
2272: if (jjtc002) {
2273: jjtree.clearNodeScope(jjtn002);
2274: jjtc002 = false;
2275: } else {
2276: jjtree.popNode();
2277: }
2278: if (jjte002 instanceof RuntimeException) {
2279: {
2280: if (true)
2281: throw (RuntimeException) jjte002;
2282: }
2283: }
2284: if (jjte002 instanceof ParseException) {
2285: {
2286: if (true)
2287: throw (ParseException) jjte002;
2288: }
2289: }
2290: {
2291: if (true)
2292: throw (Error) jjte002;
2293: }
2294: } finally {
2295: if (jjtc002) {
2296: jjtree.closeNodeScope(jjtn002, 2);
2297: }
2298: }
2299: break;
2300: case LOGICAL_LE:
2301: jj_consume_token(LOGICAL_LE);
2302: ASTLENode jjtn003 = new ASTLENode(this , JJTLENODE);
2303: boolean jjtc003 = true;
2304: jjtree.openNodeScope(jjtn003);
2305: try {
2306: AdditiveExpression();
2307: } catch (Throwable jjte003) {
2308: if (jjtc003) {
2309: jjtree.clearNodeScope(jjtn003);
2310: jjtc003 = false;
2311: } else {
2312: jjtree.popNode();
2313: }
2314: if (jjte003 instanceof RuntimeException) {
2315: {
2316: if (true)
2317: throw (RuntimeException) jjte003;
2318: }
2319: }
2320: if (jjte003 instanceof ParseException) {
2321: {
2322: if (true)
2323: throw (ParseException) jjte003;
2324: }
2325: }
2326: {
2327: if (true)
2328: throw (Error) jjte003;
2329: }
2330: } finally {
2331: if (jjtc003) {
2332: jjtree.closeNodeScope(jjtn003, 2);
2333: }
2334: }
2335: break;
2336: case LOGICAL_GE:
2337: jj_consume_token(LOGICAL_GE);
2338: ASTGENode jjtn004 = new ASTGENode(this , JJTGENODE);
2339: boolean jjtc004 = true;
2340: jjtree.openNodeScope(jjtn004);
2341: try {
2342: AdditiveExpression();
2343: } catch (Throwable jjte004) {
2344: if (jjtc004) {
2345: jjtree.clearNodeScope(jjtn004);
2346: jjtc004 = false;
2347: } else {
2348: jjtree.popNode();
2349: }
2350: if (jjte004 instanceof RuntimeException) {
2351: {
2352: if (true)
2353: throw (RuntimeException) jjte004;
2354: }
2355: }
2356: if (jjte004 instanceof ParseException) {
2357: {
2358: if (true)
2359: throw (ParseException) jjte004;
2360: }
2361: }
2362: {
2363: if (true)
2364: throw (Error) jjte004;
2365: }
2366: } finally {
2367: if (jjtc004) {
2368: jjtree.closeNodeScope(jjtn004, 2);
2369: }
2370: }
2371: break;
2372: default:
2373: jj_la1[50] = jj_gen;
2374: jj_consume_token(-1);
2375: throw new ParseException();
2376: }
2377: }
2378: }
2379:
2380: final public void AdditiveExpression() throws ParseException {
2381: MultiplicativeExpression();
2382: label_18: while (true) {
2383: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2384: case MINUS:
2385: case PLUS:
2386: ;
2387: break;
2388: default:
2389: jj_la1[51] = jj_gen;
2390: break label_18;
2391: }
2392: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2393: case PLUS:
2394: jj_consume_token(PLUS);
2395: ASTAddNode jjtn001 = new ASTAddNode(this , JJTADDNODE);
2396: boolean jjtc001 = true;
2397: jjtree.openNodeScope(jjtn001);
2398: try {
2399: MultiplicativeExpression();
2400: } catch (Throwable jjte001) {
2401: if (jjtc001) {
2402: jjtree.clearNodeScope(jjtn001);
2403: jjtc001 = false;
2404: } else {
2405: jjtree.popNode();
2406: }
2407: if (jjte001 instanceof RuntimeException) {
2408: {
2409: if (true)
2410: throw (RuntimeException) jjte001;
2411: }
2412: }
2413: if (jjte001 instanceof ParseException) {
2414: {
2415: if (true)
2416: throw (ParseException) jjte001;
2417: }
2418: }
2419: {
2420: if (true)
2421: throw (Error) jjte001;
2422: }
2423: } finally {
2424: if (jjtc001) {
2425: jjtree.closeNodeScope(jjtn001, 2);
2426: }
2427: }
2428: break;
2429: case MINUS:
2430: jj_consume_token(MINUS);
2431: ASTSubtractNode jjtn002 = new ASTSubtractNode(this ,
2432: JJTSUBTRACTNODE);
2433: boolean jjtc002 = true;
2434: jjtree.openNodeScope(jjtn002);
2435: try {
2436: MultiplicativeExpression();
2437: } catch (Throwable jjte002) {
2438: if (jjtc002) {
2439: jjtree.clearNodeScope(jjtn002);
2440: jjtc002 = false;
2441: } else {
2442: jjtree.popNode();
2443: }
2444: if (jjte002 instanceof RuntimeException) {
2445: {
2446: if (true)
2447: throw (RuntimeException) jjte002;
2448: }
2449: }
2450: if (jjte002 instanceof ParseException) {
2451: {
2452: if (true)
2453: throw (ParseException) jjte002;
2454: }
2455: }
2456: {
2457: if (true)
2458: throw (Error) jjte002;
2459: }
2460: } finally {
2461: if (jjtc002) {
2462: jjtree.closeNodeScope(jjtn002, 2);
2463: }
2464: }
2465: break;
2466: default:
2467: jj_la1[52] = jj_gen;
2468: jj_consume_token(-1);
2469: throw new ParseException();
2470: }
2471: }
2472: }
2473:
2474: final public void MultiplicativeExpression() throws ParseException {
2475: UnaryExpression();
2476: label_19: while (true) {
2477: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2478: case MULTIPLY:
2479: case DIVIDE:
2480: case MODULUS:
2481: ;
2482: break;
2483: default:
2484: jj_la1[53] = jj_gen;
2485: break label_19;
2486: }
2487: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2488: case MULTIPLY:
2489: jj_consume_token(MULTIPLY);
2490: ASTMulNode jjtn001 = new ASTMulNode(this , JJTMULNODE);
2491: boolean jjtc001 = true;
2492: jjtree.openNodeScope(jjtn001);
2493: try {
2494: UnaryExpression();
2495: } catch (Throwable jjte001) {
2496: if (jjtc001) {
2497: jjtree.clearNodeScope(jjtn001);
2498: jjtc001 = false;
2499: } else {
2500: jjtree.popNode();
2501: }
2502: if (jjte001 instanceof RuntimeException) {
2503: {
2504: if (true)
2505: throw (RuntimeException) jjte001;
2506: }
2507: }
2508: if (jjte001 instanceof ParseException) {
2509: {
2510: if (true)
2511: throw (ParseException) jjte001;
2512: }
2513: }
2514: {
2515: if (true)
2516: throw (Error) jjte001;
2517: }
2518: } finally {
2519: if (jjtc001) {
2520: jjtree.closeNodeScope(jjtn001, 2);
2521: }
2522: }
2523: break;
2524: case DIVIDE:
2525: jj_consume_token(DIVIDE);
2526: ASTDivNode jjtn002 = new ASTDivNode(this , JJTDIVNODE);
2527: boolean jjtc002 = true;
2528: jjtree.openNodeScope(jjtn002);
2529: try {
2530: UnaryExpression();
2531: } catch (Throwable jjte002) {
2532: if (jjtc002) {
2533: jjtree.clearNodeScope(jjtn002);
2534: jjtc002 = false;
2535: } else {
2536: jjtree.popNode();
2537: }
2538: if (jjte002 instanceof RuntimeException) {
2539: {
2540: if (true)
2541: throw (RuntimeException) jjte002;
2542: }
2543: }
2544: if (jjte002 instanceof ParseException) {
2545: {
2546: if (true)
2547: throw (ParseException) jjte002;
2548: }
2549: }
2550: {
2551: if (true)
2552: throw (Error) jjte002;
2553: }
2554: } finally {
2555: if (jjtc002) {
2556: jjtree.closeNodeScope(jjtn002, 2);
2557: }
2558: }
2559: break;
2560: case MODULUS:
2561: jj_consume_token(MODULUS);
2562: ASTModNode jjtn003 = new ASTModNode(this , JJTMODNODE);
2563: boolean jjtc003 = true;
2564: jjtree.openNodeScope(jjtn003);
2565: try {
2566: UnaryExpression();
2567: } catch (Throwable jjte003) {
2568: if (jjtc003) {
2569: jjtree.clearNodeScope(jjtn003);
2570: jjtc003 = false;
2571: } else {
2572: jjtree.popNode();
2573: }
2574: if (jjte003 instanceof RuntimeException) {
2575: {
2576: if (true)
2577: throw (RuntimeException) jjte003;
2578: }
2579: }
2580: if (jjte003 instanceof ParseException) {
2581: {
2582: if (true)
2583: throw (ParseException) jjte003;
2584: }
2585: }
2586: {
2587: if (true)
2588: throw (Error) jjte003;
2589: }
2590: } finally {
2591: if (jjtc003) {
2592: jjtree.closeNodeScope(jjtn003, 2);
2593: }
2594: }
2595: break;
2596: default:
2597: jj_la1[54] = jj_gen;
2598: jj_consume_token(-1);
2599: throw new ParseException();
2600: }
2601: }
2602: }
2603:
2604: final public void UnaryExpression() throws ParseException {
2605: if (jj_2_11(2)) {
2606: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2607: case WHITESPACE:
2608: jj_consume_token(WHITESPACE);
2609: break;
2610: default:
2611: jj_la1[55] = jj_gen;
2612: ;
2613: }
2614: jj_consume_token(LOGICAL_NOT);
2615: ASTNotNode jjtn001 = new ASTNotNode(this , JJTNOTNODE);
2616: boolean jjtc001 = true;
2617: jjtree.openNodeScope(jjtn001);
2618: try {
2619: UnaryExpression();
2620: } catch (Throwable jjte001) {
2621: if (jjtc001) {
2622: jjtree.clearNodeScope(jjtn001);
2623: jjtc001 = false;
2624: } else {
2625: jjtree.popNode();
2626: }
2627: if (jjte001 instanceof RuntimeException) {
2628: {
2629: if (true)
2630: throw (RuntimeException) jjte001;
2631: }
2632: }
2633: if (jjte001 instanceof ParseException) {
2634: {
2635: if (true)
2636: throw (ParseException) jjte001;
2637: }
2638: }
2639: {
2640: if (true)
2641: throw (Error) jjte001;
2642: }
2643: } finally {
2644: if (jjtc001) {
2645: jjtree.closeNodeScope(jjtn001, 1);
2646: }
2647: }
2648: } else {
2649: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2650: case LBRACKET:
2651: case LEFT_CURLEY:
2652: case LPAREN:
2653: case WHITESPACE:
2654: case STRING_LITERAL:
2655: case TRUE:
2656: case FALSE:
2657: case INTEGER_LITERAL:
2658: case FLOATING_POINT_LITERAL:
2659: case IDENTIFIER:
2660: case LCURLY:
2661: PrimaryExpression();
2662: break;
2663: default:
2664: jj_la1[56] = jj_gen;
2665: jj_consume_token(-1);
2666: throw new ParseException();
2667: }
2668: }
2669: }
2670:
2671: final public void PrimaryExpression() throws ParseException {
2672: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2673: case WHITESPACE:
2674: jj_consume_token(WHITESPACE);
2675: break;
2676: default:
2677: jj_la1[57] = jj_gen;
2678: ;
2679: }
2680: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2681: case STRING_LITERAL:
2682: StringLiteral();
2683: break;
2684: case IDENTIFIER:
2685: case LCURLY:
2686: Reference();
2687: break;
2688: case INTEGER_LITERAL:
2689: IntegerLiteral();
2690: break;
2691: default:
2692: jj_la1[58] = jj_gen;
2693: if (jj_2_12(2147483647)) {
2694: IntegerRange();
2695: } else {
2696: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2697: case FLOATING_POINT_LITERAL:
2698: FloatingPointLiteral();
2699: break;
2700: case LEFT_CURLEY:
2701: Map();
2702: break;
2703: case LBRACKET:
2704: ObjectArray();
2705: break;
2706: case TRUE:
2707: True();
2708: break;
2709: case FALSE:
2710: False();
2711: break;
2712: case LPAREN:
2713: jj_consume_token(LPAREN);
2714: Expression();
2715: jj_consume_token(RPAREN);
2716: break;
2717: default:
2718: jj_la1[59] = jj_gen;
2719: jj_consume_token(-1);
2720: throw new ParseException();
2721: }
2722: }
2723: }
2724: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2725: case WHITESPACE:
2726: jj_consume_token(WHITESPACE);
2727: break;
2728: default:
2729: jj_la1[60] = jj_gen;
2730: ;
2731: }
2732: }
2733:
2734: final private boolean jj_2_1(int xla) {
2735: jj_la = xla;
2736: jj_lastpos = jj_scanpos = token;
2737: try {
2738: return !jj_3_1();
2739: } catch (LookaheadSuccess ls) {
2740: return true;
2741: } finally {
2742: jj_save(0, xla);
2743: }
2744: }
2745:
2746: final private boolean jj_2_2(int xla) {
2747: jj_la = xla;
2748: jj_lastpos = jj_scanpos = token;
2749: try {
2750: return !jj_3_2();
2751: } catch (LookaheadSuccess ls) {
2752: return true;
2753: } finally {
2754: jj_save(1, xla);
2755: }
2756: }
2757:
2758: final private boolean jj_2_3(int xla) {
2759: jj_la = xla;
2760: jj_lastpos = jj_scanpos = token;
2761: try {
2762: return !jj_3_3();
2763: } catch (LookaheadSuccess ls) {
2764: return true;
2765: } finally {
2766: jj_save(2, xla);
2767: }
2768: }
2769:
2770: final private boolean jj_2_4(int xla) {
2771: jj_la = xla;
2772: jj_lastpos = jj_scanpos = token;
2773: try {
2774: return !jj_3_4();
2775: } catch (LookaheadSuccess ls) {
2776: return true;
2777: } finally {
2778: jj_save(3, xla);
2779: }
2780: }
2781:
2782: final private boolean jj_2_5(int xla) {
2783: jj_la = xla;
2784: jj_lastpos = jj_scanpos = token;
2785: try {
2786: return !jj_3_5();
2787: } catch (LookaheadSuccess ls) {
2788: return true;
2789: } finally {
2790: jj_save(4, xla);
2791: }
2792: }
2793:
2794: final private boolean jj_2_6(int xla) {
2795: jj_la = xla;
2796: jj_lastpos = jj_scanpos = token;
2797: try {
2798: return !jj_3_6();
2799: } catch (LookaheadSuccess ls) {
2800: return true;
2801: } finally {
2802: jj_save(5, xla);
2803: }
2804: }
2805:
2806: final private boolean jj_2_7(int xla) {
2807: jj_la = xla;
2808: jj_lastpos = jj_scanpos = token;
2809: try {
2810: return !jj_3_7();
2811: } catch (LookaheadSuccess ls) {
2812: return true;
2813: } finally {
2814: jj_save(6, xla);
2815: }
2816: }
2817:
2818: final private boolean jj_2_8(int xla) {
2819: jj_la = xla;
2820: jj_lastpos = jj_scanpos = token;
2821: try {
2822: return !jj_3_8();
2823: } catch (LookaheadSuccess ls) {
2824: return true;
2825: } finally {
2826: jj_save(7, xla);
2827: }
2828: }
2829:
2830: final private boolean jj_2_9(int xla) {
2831: jj_la = xla;
2832: jj_lastpos = jj_scanpos = token;
2833: try {
2834: return !jj_3_9();
2835: } catch (LookaheadSuccess ls) {
2836: return true;
2837: } finally {
2838: jj_save(8, xla);
2839: }
2840: }
2841:
2842: final private boolean jj_2_10(int xla) {
2843: jj_la = xla;
2844: jj_lastpos = jj_scanpos = token;
2845: try {
2846: return !jj_3_10();
2847: } catch (LookaheadSuccess ls) {
2848: return true;
2849: } finally {
2850: jj_save(9, xla);
2851: }
2852: }
2853:
2854: final private boolean jj_2_11(int xla) {
2855: jj_la = xla;
2856: jj_lastpos = jj_scanpos = token;
2857: try {
2858: return !jj_3_11();
2859: } catch (LookaheadSuccess ls) {
2860: return true;
2861: } finally {
2862: jj_save(10, xla);
2863: }
2864: }
2865:
2866: final private boolean jj_2_12(int xla) {
2867: jj_la = xla;
2868: jj_lastpos = jj_scanpos = token;
2869: try {
2870: return !jj_3_12();
2871: } catch (LookaheadSuccess ls) {
2872: return true;
2873: } finally {
2874: jj_save(11, xla);
2875: }
2876: }
2877:
2878: final private boolean jj_3R_82() {
2879: if (jj_scan_token(COMMA))
2880: return true;
2881: if (jj_3R_25())
2882: return true;
2883: return false;
2884: }
2885:
2886: final private boolean jj_3_8() {
2887: if (jj_3R_29())
2888: return true;
2889: return false;
2890: }
2891:
2892: final private boolean jj_3R_26() {
2893: if (jj_3R_20())
2894: return true;
2895: return false;
2896: }
2897:
2898: final private boolean jj_3R_66() {
2899: if (jj_scan_token(FALSE))
2900: return true;
2901: return false;
2902: }
2903:
2904: final private boolean jj_3R_65() {
2905: if (jj_scan_token(TRUE))
2906: return true;
2907: return false;
2908: }
2909:
2910: final private boolean jj_3_9() {
2911: if (jj_scan_token(DOT))
2912: return true;
2913: Token xsp;
2914: xsp = jj_scanpos;
2915: if (jj_3_10()) {
2916: jj_scanpos = xsp;
2917: if (jj_3R_30())
2918: return true;
2919: }
2920: return false;
2921: }
2922:
2923: final private boolean jj_3R_57() {
2924: if (jj_3R_25())
2925: return true;
2926: Token xsp;
2927: while (true) {
2928: xsp = jj_scanpos;
2929: if (jj_3R_82()) {
2930: jj_scanpos = xsp;
2931: break;
2932: }
2933: }
2934: return false;
2935: }
2936:
2937: final private boolean jj_3_7() {
2938: if (jj_scan_token(DOT))
2939: return true;
2940: Token xsp;
2941: xsp = jj_scanpos;
2942: if (jj_3_8()) {
2943: jj_scanpos = xsp;
2944: if (jj_3R_28())
2945: return true;
2946: }
2947: return false;
2948: }
2949:
2950: final private boolean jj_3_2() {
2951: if (jj_scan_token(DOUBLE_ESCAPE))
2952: return true;
2953: return false;
2954: }
2955:
2956: final private boolean jj_3R_35() {
2957: if (jj_scan_token(LCURLY))
2958: return true;
2959: if (jj_scan_token(IDENTIFIER))
2960: return true;
2961: Token xsp;
2962: while (true) {
2963: xsp = jj_scanpos;
2964: if (jj_3_9()) {
2965: jj_scanpos = xsp;
2966: break;
2967: }
2968: }
2969: if (jj_scan_token(RCURLY))
2970: return true;
2971: return false;
2972: }
2973:
2974: final private boolean jj_3_12() {
2975: if (jj_scan_token(LBRACKET))
2976: return true;
2977: Token xsp;
2978: xsp = jj_scanpos;
2979: if (jj_scan_token(26))
2980: jj_scanpos = xsp;
2981: xsp = jj_scanpos;
2982: if (jj_3R_32()) {
2983: jj_scanpos = xsp;
2984: if (jj_3R_33())
2985: return true;
2986: }
2987: xsp = jj_scanpos;
2988: if (jj_scan_token(26))
2989: jj_scanpos = xsp;
2990: if (jj_scan_token(DOUBLEDOT))
2991: return true;
2992: return false;
2993: }
2994:
2995: final private boolean jj_3R_34() {
2996: if (jj_scan_token(IDENTIFIER))
2997: return true;
2998: Token xsp;
2999: while (true) {
3000: xsp = jj_scanpos;
3001: if (jj_3_7()) {
3002: jj_scanpos = xsp;
3003: break;
3004: }
3005: }
3006: return false;
3007: }
3008:
3009: final private boolean jj_3R_81() {
3010: if (jj_scan_token(LPAREN))
3011: return true;
3012: return false;
3013: }
3014:
3015: final private boolean jj_3R_80() {
3016: if (jj_3R_66())
3017: return true;
3018: return false;
3019: }
3020:
3021: final private boolean jj_3R_79() {
3022: if (jj_3R_65())
3023: return true;
3024: return false;
3025: }
3026:
3027: final private boolean jj_3R_20() {
3028: Token xsp;
3029: xsp = jj_scanpos;
3030: if (jj_3R_34()) {
3031: jj_scanpos = xsp;
3032: if (jj_3R_35())
3033: return true;
3034: }
3035: return false;
3036: }
3037:
3038: final private boolean jj_3R_78() {
3039: if (jj_3R_64())
3040: return true;
3041: return false;
3042: }
3043:
3044: final private boolean jj_3R_77() {
3045: if (jj_3R_63())
3046: return true;
3047: return false;
3048: }
3049:
3050: final private boolean jj_3R_76() {
3051: if (jj_3R_62())
3052: return true;
3053: return false;
3054: }
3055:
3056: final private boolean jj_3R_75() {
3057: if (jj_3R_61())
3058: return true;
3059: return false;
3060: }
3061:
3062: final private boolean jj_3R_74() {
3063: if (jj_3R_36())
3064: return true;
3065: return false;
3066: }
3067:
3068: final private boolean jj_3R_73() {
3069: if (jj_3R_20())
3070: return true;
3071: return false;
3072: }
3073:
3074: final private boolean jj_3_6() {
3075: if (jj_scan_token(LBRACKET))
3076: return true;
3077: Token xsp;
3078: xsp = jj_scanpos;
3079: if (jj_scan_token(26))
3080: jj_scanpos = xsp;
3081: xsp = jj_scanpos;
3082: if (jj_3R_26()) {
3083: jj_scanpos = xsp;
3084: if (jj_3R_27())
3085: return true;
3086: }
3087: xsp = jj_scanpos;
3088: if (jj_scan_token(26))
3089: jj_scanpos = xsp;
3090: if (jj_scan_token(DOUBLEDOT))
3091: return true;
3092: return false;
3093: }
3094:
3095: final private boolean jj_3R_29() {
3096: if (jj_3R_56())
3097: return true;
3098: if (jj_scan_token(LPAREN))
3099: return true;
3100: Token xsp;
3101: xsp = jj_scanpos;
3102: if (jj_3R_57())
3103: jj_scanpos = xsp;
3104: if (jj_scan_token(REFMOD2_RPAREN))
3105: return true;
3106: return false;
3107: }
3108:
3109: final private boolean jj_3R_72() {
3110: if (jj_3R_60())
3111: return true;
3112: return false;
3113: }
3114:
3115: final private boolean jj_3R_67() {
3116: Token xsp;
3117: xsp = jj_scanpos;
3118: if (jj_scan_token(26))
3119: jj_scanpos = xsp;
3120: xsp = jj_scanpos;
3121: if (jj_3R_72()) {
3122: jj_scanpos = xsp;
3123: if (jj_3R_73()) {
3124: jj_scanpos = xsp;
3125: if (jj_3R_74()) {
3126: jj_scanpos = xsp;
3127: if (jj_3R_75()) {
3128: jj_scanpos = xsp;
3129: if (jj_3R_76()) {
3130: jj_scanpos = xsp;
3131: if (jj_3R_77()) {
3132: jj_scanpos = xsp;
3133: if (jj_3R_78()) {
3134: jj_scanpos = xsp;
3135: if (jj_3R_79()) {
3136: jj_scanpos = xsp;
3137: if (jj_3R_80()) {
3138: jj_scanpos = xsp;
3139: if (jj_3R_81())
3140: return true;
3141: }
3142: }
3143: }
3144: }
3145: }
3146: }
3147: }
3148: }
3149: }
3150: return false;
3151: }
3152:
3153: final private boolean jj_3R_55() {
3154: if (jj_3R_62())
3155: return true;
3156: return false;
3157: }
3158:
3159: final private boolean jj_3R_54() {
3160: if (jj_3R_20())
3161: return true;
3162: return false;
3163: }
3164:
3165: final private boolean jj_3R_53() {
3166: if (jj_3R_66())
3167: return true;
3168: return false;
3169: }
3170:
3171: final private boolean jj_3R_85() {
3172: if (jj_scan_token(COMMA))
3173: return true;
3174: if (jj_3R_25())
3175: return true;
3176: if (jj_scan_token(COLON))
3177: return true;
3178: if (jj_3R_25())
3179: return true;
3180: return false;
3181: }
3182:
3183: final private boolean jj_3R_52() {
3184: if (jj_3R_65())
3185: return true;
3186: return false;
3187: }
3188:
3189: final private boolean jj_3R_31() {
3190: Token xsp;
3191: xsp = jj_scanpos;
3192: if (jj_3_11()) {
3193: jj_scanpos = xsp;
3194: if (jj_3R_58())
3195: return true;
3196: }
3197: return false;
3198: }
3199:
3200: final private boolean jj_3_11() {
3201: Token xsp;
3202: xsp = jj_scanpos;
3203: if (jj_scan_token(26))
3204: jj_scanpos = xsp;
3205: if (jj_scan_token(LOGICAL_NOT))
3206: return true;
3207: if (jj_3R_31())
3208: return true;
3209: return false;
3210: }
3211:
3212: final private boolean jj_3R_58() {
3213: if (jj_3R_67())
3214: return true;
3215: return false;
3216: }
3217:
3218: final private boolean jj_3R_51() {
3219: if (jj_3R_64())
3220: return true;
3221: return false;
3222: }
3223:
3224: final private boolean jj_3R_50() {
3225: if (jj_3R_63())
3226: return true;
3227: return false;
3228: }
3229:
3230: final private boolean jj_3R_49() {
3231: if (jj_3R_61())
3232: return true;
3233: return false;
3234: }
3235:
3236: final private boolean jj_3R_48() {
3237: if (jj_3R_36())
3238: return true;
3239: return false;
3240: }
3241:
3242: final private boolean jj_3R_47() {
3243: if (jj_3R_60())
3244: return true;
3245: return false;
3246: }
3247:
3248: final private boolean jj_3R_22() {
3249: if (jj_3R_36())
3250: return true;
3251: return false;
3252: }
3253:
3254: final private boolean jj_3R_84() {
3255: if (jj_3R_36())
3256: return true;
3257: return false;
3258: }
3259:
3260: final private boolean jj_3R_69() {
3261: if (jj_3R_36())
3262: return true;
3263: return false;
3264: }
3265:
3266: final private boolean jj_3R_86() {
3267: if (jj_scan_token(COMMA))
3268: return true;
3269: if (jj_3R_25())
3270: return true;
3271: return false;
3272: }
3273:
3274: final private boolean jj_3R_25() {
3275: Token xsp;
3276: xsp = jj_scanpos;
3277: if (jj_scan_token(26))
3278: jj_scanpos = xsp;
3279: xsp = jj_scanpos;
3280: if (jj_3R_47()) {
3281: jj_scanpos = xsp;
3282: if (jj_3R_48()) {
3283: jj_scanpos = xsp;
3284: if (jj_3R_49()) {
3285: jj_scanpos = xsp;
3286: if (jj_3R_50()) {
3287: jj_scanpos = xsp;
3288: if (jj_3R_51()) {
3289: jj_scanpos = xsp;
3290: if (jj_3R_52()) {
3291: jj_scanpos = xsp;
3292: if (jj_3R_53()) {
3293: jj_scanpos = xsp;
3294: if (jj_3R_54()) {
3295: jj_scanpos = xsp;
3296: if (jj_3R_55())
3297: return true;
3298: }
3299: }
3300: }
3301: }
3302: }
3303: }
3304: }
3305: }
3306: xsp = jj_scanpos;
3307: if (jj_scan_token(26))
3308: jj_scanpos = xsp;
3309: return false;
3310: }
3311:
3312: final private boolean jj_3_1() {
3313: if (jj_3R_20())
3314: return true;
3315: return false;
3316: }
3317:
3318: final private boolean jj_3R_21() {
3319: if (jj_3R_20())
3320: return true;
3321: return false;
3322: }
3323:
3324: final private boolean jj_3R_83() {
3325: if (jj_3R_20())
3326: return true;
3327: return false;
3328: }
3329:
3330: final private boolean jj_3R_68() {
3331: if (jj_3R_20())
3332: return true;
3333: return false;
3334: }
3335:
3336: final private boolean jj_3R_71() {
3337: if (jj_3R_25())
3338: return true;
3339: Token xsp;
3340: while (true) {
3341: xsp = jj_scanpos;
3342: if (jj_3R_86()) {
3343: jj_scanpos = xsp;
3344: break;
3345: }
3346: }
3347: return false;
3348: }
3349:
3350: final private boolean jj_3R_61() {
3351: if (jj_scan_token(LBRACKET))
3352: return true;
3353: Token xsp;
3354: xsp = jj_scanpos;
3355: if (jj_scan_token(26))
3356: jj_scanpos = xsp;
3357: xsp = jj_scanpos;
3358: if (jj_3R_68()) {
3359: jj_scanpos = xsp;
3360: if (jj_3R_69())
3361: return true;
3362: }
3363: xsp = jj_scanpos;
3364: if (jj_scan_token(26))
3365: jj_scanpos = xsp;
3366: if (jj_scan_token(DOUBLEDOT))
3367: return true;
3368: xsp = jj_scanpos;
3369: if (jj_scan_token(26))
3370: jj_scanpos = xsp;
3371: xsp = jj_scanpos;
3372: if (jj_3R_83()) {
3373: jj_scanpos = xsp;
3374: if (jj_3R_84())
3375: return true;
3376: }
3377: xsp = jj_scanpos;
3378: if (jj_scan_token(26))
3379: jj_scanpos = xsp;
3380: if (jj_scan_token(RBRACKET))
3381: return true;
3382: return false;
3383: }
3384:
3385: final private boolean jj_3R_64() {
3386: if (jj_scan_token(LBRACKET))
3387: return true;
3388: Token xsp;
3389: xsp = jj_scanpos;
3390: if (jj_3R_71())
3391: jj_scanpos = xsp;
3392: if (jj_scan_token(RBRACKET))
3393: return true;
3394: return false;
3395: }
3396:
3397: final private boolean jj_3R_46() {
3398: if (jj_3R_66())
3399: return true;
3400: return false;
3401: }
3402:
3403: final private boolean jj_3R_70() {
3404: Token xsp;
3405: xsp = jj_scanpos;
3406: if (jj_scan_token(26))
3407: jj_scanpos = xsp;
3408: return false;
3409: }
3410:
3411: final private boolean jj_3_5() {
3412: if (jj_3R_25())
3413: return true;
3414: if (jj_scan_token(COLON))
3415: return true;
3416: if (jj_3R_25())
3417: return true;
3418: Token xsp;
3419: while (true) {
3420: xsp = jj_scanpos;
3421: if (jj_3R_85()) {
3422: jj_scanpos = xsp;
3423: break;
3424: }
3425: }
3426: return false;
3427: }
3428:
3429: final private boolean jj_3R_45() {
3430: if (jj_3R_65())
3431: return true;
3432: return false;
3433: }
3434:
3435: final private boolean jj_3R_63() {
3436: if (jj_scan_token(LEFT_CURLEY))
3437: return true;
3438: Token xsp;
3439: xsp = jj_scanpos;
3440: if (jj_3_5()) {
3441: jj_scanpos = xsp;
3442: if (jj_3R_70())
3443: return true;
3444: }
3445: if (jj_scan_token(RIGHT_CURLEY))
3446: return true;
3447: return false;
3448: }
3449:
3450: final private boolean jj_3_3() {
3451: if (jj_scan_token(LBRACKET))
3452: return true;
3453: Token xsp;
3454: xsp = jj_scanpos;
3455: if (jj_scan_token(26))
3456: jj_scanpos = xsp;
3457: xsp = jj_scanpos;
3458: if (jj_3R_21()) {
3459: jj_scanpos = xsp;
3460: if (jj_3R_22())
3461: return true;
3462: }
3463: xsp = jj_scanpos;
3464: if (jj_scan_token(26))
3465: jj_scanpos = xsp;
3466: if (jj_scan_token(DOUBLEDOT))
3467: return true;
3468: return false;
3469: }
3470:
3471: final private boolean jj_3R_44() {
3472: if (jj_3R_64())
3473: return true;
3474: return false;
3475: }
3476:
3477: final private boolean jj_3R_43() {
3478: if (jj_3R_63())
3479: return true;
3480: return false;
3481: }
3482:
3483: final private boolean jj_3R_42() {
3484: if (jj_3R_62())
3485: return true;
3486: return false;
3487: }
3488:
3489: final private boolean jj_3R_41() {
3490: if (jj_3R_61())
3491: return true;
3492: return false;
3493: }
3494:
3495: final private boolean jj_3R_40() {
3496: if (jj_3R_36())
3497: return true;
3498: return false;
3499: }
3500:
3501: final private boolean jj_3R_39() {
3502: if (jj_3R_60())
3503: return true;
3504: return false;
3505: }
3506:
3507: final private boolean jj_3R_23() {
3508: if (jj_scan_token(COMMA))
3509: return true;
3510: Token xsp;
3511: xsp = jj_scanpos;
3512: if (jj_scan_token(26))
3513: jj_scanpos = xsp;
3514: return false;
3515: }
3516:
3517: final private boolean jj_3R_38() {
3518: if (jj_3R_59())
3519: return true;
3520: return false;
3521: }
3522:
3523: final private boolean jj_3R_37() {
3524: if (jj_3R_20())
3525: return true;
3526: return false;
3527: }
3528:
3529: final private boolean jj_3R_24() {
3530: Token xsp;
3531: xsp = jj_scanpos;
3532: if (jj_3R_37()) {
3533: jj_scanpos = xsp;
3534: if (jj_3R_38()) {
3535: jj_scanpos = xsp;
3536: if (jj_3R_39()) {
3537: jj_scanpos = xsp;
3538: if (jj_3R_40()) {
3539: jj_scanpos = xsp;
3540: if (jj_3R_41()) {
3541: jj_scanpos = xsp;
3542: if (jj_3R_42()) {
3543: jj_scanpos = xsp;
3544: if (jj_3R_43()) {
3545: jj_scanpos = xsp;
3546: if (jj_3R_44()) {
3547: jj_scanpos = xsp;
3548: if (jj_3R_45()) {
3549: jj_scanpos = xsp;
3550: if (jj_3R_46())
3551: return true;
3552: }
3553: }
3554: }
3555: }
3556: }
3557: }
3558: }
3559: }
3560: }
3561: return false;
3562: }
3563:
3564: final private boolean jj_3R_59() {
3565: if (jj_scan_token(WORD))
3566: return true;
3567: return false;
3568: }
3569:
3570: final private boolean jj_3R_56() {
3571: if (jj_scan_token(IDENTIFIER))
3572: return true;
3573: return false;
3574: }
3575:
3576: final private boolean jj_3_4() {
3577: Token xsp;
3578: xsp = jj_scanpos;
3579: if (jj_scan_token(26))
3580: jj_scanpos = xsp;
3581: xsp = jj_scanpos;
3582: if (jj_3R_23())
3583: jj_scanpos = xsp;
3584: if (jj_3R_24())
3585: return true;
3586: return false;
3587: }
3588:
3589: final private boolean jj_3R_60() {
3590: if (jj_scan_token(STRING_LITERAL))
3591: return true;
3592: return false;
3593: }
3594:
3595: final private boolean jj_3R_30() {
3596: if (jj_3R_56())
3597: return true;
3598: return false;
3599: }
3600:
3601: final private boolean jj_3R_36() {
3602: if (jj_scan_token(INTEGER_LITERAL))
3603: return true;
3604: return false;
3605: }
3606:
3607: final private boolean jj_3R_28() {
3608: if (jj_3R_56())
3609: return true;
3610: return false;
3611: }
3612:
3613: final private boolean jj_3R_62() {
3614: if (jj_scan_token(FLOATING_POINT_LITERAL))
3615: return true;
3616: return false;
3617: }
3618:
3619: final private boolean jj_3R_33() {
3620: if (jj_3R_36())
3621: return true;
3622: return false;
3623: }
3624:
3625: final private boolean jj_3R_32() {
3626: if (jj_3R_20())
3627: return true;
3628: return false;
3629: }
3630:
3631: final private boolean jj_3R_27() {
3632: if (jj_3R_36())
3633: return true;
3634: return false;
3635: }
3636:
3637: final private boolean jj_3_10() {
3638: if (jj_3R_29())
3639: return true;
3640: return false;
3641: }
3642:
3643: public ParserTokenManager token_source;
3644: public Token token, jj_nt;
3645: private int jj_ntk;
3646: private Token jj_scanpos, jj_lastpos;
3647: private int jj_la;
3648: public boolean lookingAhead = false;
3649: private boolean jj_semLA;
3650: private int jj_gen;
3651: final private int[] jj_la1 = new int[61];
3652: static private int[] jj_la1_0;
3653: static private int[] jj_la1_1;
3654: static private int[] jj_la1_2;
3655: static {
3656: jj_la1_0();
3657: jj_la1_1();
3658: jj_la1_2();
3659: }
3660:
3661: private static void jj_la1_0() {
3662: jj_la1_0 = new int[] { 0x9bc1b00, 0x0, 0x9bc1b00, 0x400000,
3663: 0x1840000, 0x8000000, 0x30000042, 0x0, 0x4000000,
3664: 0x4000000, 0x4000000, 0x8, 0x4000000, 0x9bc1b00, 0x8,
3665: 0x4000000, 0x8, 0x3c000042, 0x4000000, 0x0, 0x4000000,
3666: 0x4000000, 0x0, 0x4000000, 0x4000000, 0x8000000,
3667: 0x30000042, 0x4000000, 0x8, 0x3c000042, 0x0, 0x0, 0x0,
3668: 0x8300300, 0x4000000, 0x9bc1b00, 0x0, 0x0, 0x0,
3669: 0x9bc1b00, 0x4000000, 0x9bc1b00, 0x4000000, 0x4000000,
3670: 0x40000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80000000,
3671: 0x80000000, 0x0, 0x0, 0x4000000, 0x3c000142, 0x4000000,
3672: 0x8000000, 0x30000142, 0x4000000, };
3673: }
3674:
3675: private static void jj_la1_1() {
3676: jj_la1_1 = new int[] { 0xc6348000, 0x48000, 0x86300000, 0x0,
3677: 0x0, 0x42100000, 0x200000, 0x6000000, 0x0, 0x0, 0x0,
3678: 0x0, 0x0, 0xc6348000, 0x0, 0x0, 0x0, 0x40300000, 0x0,
3679: 0x40100000, 0x0, 0x0, 0x40100000, 0x0, 0x0, 0x100000,
3680: 0x40200000, 0x0, 0x0, 0x40300000, 0x40000000,
3681: 0x40000000, 0x40000000, 0x80300000, 0x0, 0xc6348000,
3682: 0x10000, 0x10000, 0x20000, 0xc6348000, 0x0, 0xc6348000,
3683: 0x0, 0x0, 0x0, 0x20, 0x10, 0xc00, 0xc00, 0x3c0, 0x3c0,
3684: 0x1, 0x1, 0xe, 0xe, 0x0, 0x40300000, 0x0, 0x40100000,
3685: 0x200000, 0x0, };
3686: }
3687:
3688: private static void jj_la1_2() {
3689: jj_la1_2 = new int[] { 0x3, 0x0, 0x3, 0x0, 0x0, 0x1, 0x0, 0x0,
3690: 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x1, 0x0,
3691: 0x1, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x1,
3692: 0x0, 0x0, 0x1, 0x3, 0x0, 0x3, 0x0, 0x0, 0x0, 0x3, 0x0,
3693: 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3694: 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x1, 0x0, 0x0, };
3695: }
3696:
3697: final private JJCalls[] jj_2_rtns = new JJCalls[12];
3698: private boolean jj_rescan = false;
3699: private int jj_gc = 0;
3700:
3701: public Parser(CharStream stream) {
3702: token_source = new ParserTokenManager(stream);
3703: token = new Token();
3704: jj_ntk = -1;
3705: jj_gen = 0;
3706: for (int i = 0; i < 61; i++)
3707: jj_la1[i] = -1;
3708: for (int i = 0; i < jj_2_rtns.length; i++)
3709: jj_2_rtns[i] = new JJCalls();
3710: }
3711:
3712: public void ReInit(CharStream stream) {
3713: token_source.ReInit(stream);
3714: token = new Token();
3715: jj_ntk = -1;
3716: jjtree.reset();
3717: jj_gen = 0;
3718: for (int i = 0; i < 61; i++)
3719: jj_la1[i] = -1;
3720: for (int i = 0; i < jj_2_rtns.length; i++)
3721: jj_2_rtns[i] = new JJCalls();
3722: }
3723:
3724: public Parser(ParserTokenManager tm) {
3725: token_source = tm;
3726: token = new Token();
3727: jj_ntk = -1;
3728: jj_gen = 0;
3729: for (int i = 0; i < 61; i++)
3730: jj_la1[i] = -1;
3731: for (int i = 0; i < jj_2_rtns.length; i++)
3732: jj_2_rtns[i] = new JJCalls();
3733: }
3734:
3735: public void ReInit(ParserTokenManager tm) {
3736: token_source = tm;
3737: token = new Token();
3738: jj_ntk = -1;
3739: jjtree.reset();
3740: jj_gen = 0;
3741: for (int i = 0; i < 61; i++)
3742: jj_la1[i] = -1;
3743: for (int i = 0; i < jj_2_rtns.length; i++)
3744: jj_2_rtns[i] = new JJCalls();
3745: }
3746:
3747: final private Token jj_consume_token(int kind)
3748: throws ParseException {
3749: Token oldToken;
3750: if ((oldToken = token).next != null)
3751: token = token.next;
3752: else
3753: token = token.next = token_source.getNextToken();
3754: jj_ntk = -1;
3755: if (token.kind == kind) {
3756: jj_gen++;
3757: if (++jj_gc > 100) {
3758: jj_gc = 0;
3759: for (int i = 0; i < jj_2_rtns.length; i++) {
3760: JJCalls c = jj_2_rtns[i];
3761: while (c != null) {
3762: if (c.gen < jj_gen)
3763: c.first = null;
3764: c = c.next;
3765: }
3766: }
3767: }
3768: return token;
3769: }
3770: token = oldToken;
3771: jj_kind = kind;
3772: throw generateParseException();
3773: }
3774:
3775: static private final class LookaheadSuccess extends java.lang.Error {
3776: }
3777:
3778: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3779:
3780: final private boolean jj_scan_token(int kind) {
3781: if (jj_scanpos == jj_lastpos) {
3782: jj_la--;
3783: if (jj_scanpos.next == null) {
3784: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
3785: .getNextToken();
3786: } else {
3787: jj_lastpos = jj_scanpos = jj_scanpos.next;
3788: }
3789: } else {
3790: jj_scanpos = jj_scanpos.next;
3791: }
3792: if (jj_rescan) {
3793: int i = 0;
3794: Token tok = token;
3795: while (tok != null && tok != jj_scanpos) {
3796: i++;
3797: tok = tok.next;
3798: }
3799: if (tok != null)
3800: jj_add_error_token(kind, i);
3801: }
3802: if (jj_scanpos.kind != kind)
3803: return true;
3804: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3805: throw jj_ls;
3806: return false;
3807: }
3808:
3809: final public Token getNextToken() {
3810: if (token.next != null)
3811: token = token.next;
3812: else
3813: token = token.next = token_source.getNextToken();
3814: jj_ntk = -1;
3815: jj_gen++;
3816: return token;
3817: }
3818:
3819: final public Token getToken(int index) {
3820: Token t = lookingAhead ? jj_scanpos : token;
3821: for (int i = 0; i < index; i++) {
3822: if (t.next != null)
3823: t = t.next;
3824: else
3825: t = t.next = token_source.getNextToken();
3826: }
3827: return t;
3828: }
3829:
3830: final private int jj_ntk() {
3831: if ((jj_nt = token.next) == null)
3832: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
3833: else
3834: return (jj_ntk = jj_nt.kind);
3835: }
3836:
3837: private java.util.Vector jj_expentries = new java.util.Vector();
3838: private int[] jj_expentry;
3839: private int jj_kind = -1;
3840: private int[] jj_lasttokens = new int[100];
3841: private int jj_endpos;
3842:
3843: private void jj_add_error_token(int kind, int pos) {
3844: if (pos >= 100)
3845: return;
3846: if (pos == jj_endpos + 1) {
3847: jj_lasttokens[jj_endpos++] = kind;
3848: } else if (jj_endpos != 0) {
3849: jj_expentry = new int[jj_endpos];
3850: for (int i = 0; i < jj_endpos; i++) {
3851: jj_expentry[i] = jj_lasttokens[i];
3852: }
3853: boolean exists = false;
3854: for (java.util.Enumeration e = jj_expentries.elements(); e
3855: .hasMoreElements();) {
3856: int[] oldentry = (int[]) (e.nextElement());
3857: if (oldentry.length == jj_expentry.length) {
3858: exists = true;
3859: for (int i = 0; i < jj_expentry.length; i++) {
3860: if (oldentry[i] != jj_expentry[i]) {
3861: exists = false;
3862: break;
3863: }
3864: }
3865: if (exists)
3866: break;
3867: }
3868: }
3869: if (!exists)
3870: jj_expentries.addElement(jj_expentry);
3871: if (pos != 0)
3872: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3873: }
3874: }
3875:
3876: public ParseException generateParseException() {
3877: jj_expentries.removeAllElements();
3878: boolean[] la1tokens = new boolean[68];
3879: for (int i = 0; i < 68; i++) {
3880: la1tokens[i] = false;
3881: }
3882: if (jj_kind >= 0) {
3883: la1tokens[jj_kind] = true;
3884: jj_kind = -1;
3885: }
3886: for (int i = 0; i < 61; i++) {
3887: if (jj_la1[i] == jj_gen) {
3888: for (int j = 0; j < 32; j++) {
3889: if ((jj_la1_0[i] & (1 << j)) != 0) {
3890: la1tokens[j] = true;
3891: }
3892: if ((jj_la1_1[i] & (1 << j)) != 0) {
3893: la1tokens[32 + j] = true;
3894: }
3895: if ((jj_la1_2[i] & (1 << j)) != 0) {
3896: la1tokens[64 + j] = true;
3897: }
3898: }
3899: }
3900: }
3901: for (int i = 0; i < 68; i++) {
3902: if (la1tokens[i]) {
3903: jj_expentry = new int[1];
3904: jj_expentry[0] = i;
3905: jj_expentries.addElement(jj_expentry);
3906: }
3907: }
3908: jj_endpos = 0;
3909: jj_rescan_token();
3910: jj_add_error_token(0, 0);
3911: int[][] exptokseq = new int[jj_expentries.size()][];
3912: for (int i = 0; i < jj_expentries.size(); i++) {
3913: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
3914: }
3915: return new ParseException(token, exptokseq, tokenImage);
3916: }
3917:
3918: final public void enable_tracing() {
3919: }
3920:
3921: final public void disable_tracing() {
3922: }
3923:
3924: final private void jj_rescan_token() {
3925: jj_rescan = true;
3926: for (int i = 0; i < 12; i++) {
3927: try {
3928: JJCalls p = jj_2_rtns[i];
3929: do {
3930: if (p.gen > jj_gen) {
3931: jj_la = p.arg;
3932: jj_lastpos = jj_scanpos = p.first;
3933: switch (i) {
3934: case 0:
3935: jj_3_1();
3936: break;
3937: case 1:
3938: jj_3_2();
3939: break;
3940: case 2:
3941: jj_3_3();
3942: break;
3943: case 3:
3944: jj_3_4();
3945: break;
3946: case 4:
3947: jj_3_5();
3948: break;
3949: case 5:
3950: jj_3_6();
3951: break;
3952: case 6:
3953: jj_3_7();
3954: break;
3955: case 7:
3956: jj_3_8();
3957: break;
3958: case 8:
3959: jj_3_9();
3960: break;
3961: case 9:
3962: jj_3_10();
3963: break;
3964: case 10:
3965: jj_3_11();
3966: break;
3967: case 11:
3968: jj_3_12();
3969: break;
3970: }
3971: }
3972: p = p.next;
3973: } while (p != null);
3974: } catch (LookaheadSuccess ls) {
3975: }
3976: }
3977: jj_rescan = false;
3978: }
3979:
3980: final private void jj_save(int index, int xla) {
3981: JJCalls p = jj_2_rtns[index];
3982: while (p.gen > jj_gen) {
3983: if (p.next == null) {
3984: p = p.next = new JJCalls();
3985: break;
3986: }
3987: p = p.next;
3988: }
3989: p.gen = jj_gen + xla - jj_la;
3990: p.first = token;
3991: p.arg = xla;
3992: }
3993:
3994: static final class JJCalls {
3995: int gen;
3996: Token first;
3997: int arg;
3998: JJCalls next;
3999: }
4000:
4001: }
|