0001: /* Generated By:JavaCC: Do not edit this line. FMParser.java */
0002: package freemarker.core;
0003:
0004: import freemarker.template.*;
0005: import freemarker.template.utility.StringUtil;
0006: import freemarker.template.utility.DeepUnwrap;
0007: import java.io.*;
0008: import java.util.*;
0009:
0010: /**
0011: * This class is generated by JavaCC from a grammar file.
0012: */
0013: public class FMParser implements FMParserConstants {
0014:
0015: // Necessary for adding macros and setting location info.
0016: Template template;
0017: private String templateName;
0018:
0019: // variables that keep track of whether we are in a loop or a switch.
0020: private int loopNesting, switchNesting;
0021: private boolean inMacro, inFunction, stripWhitespace, stripText;
0022: private LinkedList escapes = new LinkedList();
0023: private int contentNesting; // for stripText
0024:
0025: /**
0026: * Create an FM expression parser using a string.
0027: */
0028: static public FMParser createExpressionParser(String s) {
0029: SimpleCharStream scs = new SimpleCharStream(
0030: new StringReader(s), 1, 1, s.length());
0031: FMParserTokenManager token_source = new FMParserTokenManager(
0032: scs);
0033: token_source.SwitchTo(FMParserConstants.FM_EXPRESSION);
0034: return new FMParser(token_source);
0035: }
0036:
0037: /**
0038: * Constructs a new parser object.
0039: * @param template The template associated with this parser.
0040: * @param reader The character stream to use as input
0041: * @param strictEscapeSyntax Whether FreeMarker directives must start with a #
0042: */
0043: public FMParser(Template template, Reader reader,
0044: boolean strictEscapeSyntax, boolean stripWhitespace) {
0045: this (reader);
0046: this .template = template;
0047: token_source.strictEscapeSyntax = strictEscapeSyntax;
0048: this .templateName = template != null ? template.getName() : "";
0049: token_source.templateName = templateName;
0050: this .stripWhitespace = stripWhitespace;
0051: }
0052:
0053: public FMParser(Template template, Reader reader,
0054: boolean strictEscapeSyntax, boolean stripWhitespace,
0055: int tagSyntax) {
0056: this (template, reader, strictEscapeSyntax, stripWhitespace);
0057: switch (tagSyntax) {
0058: case Configuration.AUTO_DETECT_TAG_SYNTAX:
0059: token_source.autodetectTagSyntax = true;
0060: break;
0061: case Configuration.ANGLE_BRACKET_TAG_SYNTAX:
0062: token_source.altDirectiveSyntax = false;
0063: break;
0064: case Configuration.SQUARE_BRACKET_TAG_SYNTAX:
0065: token_source.altDirectiveSyntax = true;
0066: break;
0067: default:
0068: throw new IllegalArgumentException(
0069: "Illegal argument for tagSyntax");
0070: }
0071: }
0072:
0073: public FMParser(String template) {
0074: this (null, new StringReader(template), true, true);
0075: }
0076:
0077: private String getErrorStart(Token t) {
0078: return "Error in template: " + template.getName()
0079: + "\non line " + t.beginLine + ", column "
0080: + t.beginColumn;
0081: }
0082:
0083: /**
0084: * Throw an exception if the expression passed in is a String
0085: * Literal
0086: */
0087: private void notStringLiteral(Expression exp, String expected)
0088: throws ParseException {
0089: if (exp instanceof StringLiteral) {
0090: String msg = "Error " + exp.getStartLocation()
0091: + "\nFound string literal: " + exp
0092: + "\nExpecting: " + expected;
0093: throw new ParseException(msg, exp);
0094: }
0095: }
0096:
0097: /**
0098: * Throw an exception if the expression passed in is a Number
0099: * Literal
0100: */
0101: private void notNumberLiteral(Expression exp, String expected)
0102: throws ParseException {
0103: if (exp instanceof NumberLiteral) {
0104: String msg = "Error " + exp.getStartLocation()
0105: + "\nFound number literal: "
0106: + exp.getCanonicalForm() + "\nExpecting "
0107: + expected;
0108: throw new ParseException(msg, exp);
0109: }
0110: }
0111:
0112: /**
0113: * Throw an exception if the expression passed in is a boolean
0114: * Literal
0115: */
0116: private void notBooleanLiteral(Expression exp, String expected)
0117: throws ParseException {
0118: if (exp instanceof BooleanLiteral) {
0119: String msg = "Error " + exp.getStartLocation()
0120: + "\nFound: " + exp.getCanonicalForm()
0121: + "\nExpecting " + expected;
0122: throw new ParseException(msg, exp);
0123: }
0124: }
0125:
0126: /**
0127: * Throw an exception if the expression passed in is a Hash
0128: * Literal
0129: */
0130: private void notHashLiteral(Expression exp, String expected)
0131: throws ParseException {
0132: if (exp instanceof HashLiteral) {
0133: String msg = "Error " + exp.getStartLocation()
0134: + "\nFound hash literal: " + exp.getCanonicalForm()
0135: + "\nExpecting " + expected;
0136: throw new ParseException(msg, exp);
0137: }
0138: }
0139:
0140: /**
0141: * Throw an exception if the expression passed in is a List
0142: * Literal
0143: */
0144:
0145: private void notListLiteral(Expression exp, String expected)
0146: throws ParseException {
0147: if (exp instanceof ListLiteral) {
0148: String msg = "Error " + exp.getStartLocation()
0149: + "\nFound list literal: " + exp.getCanonicalForm()
0150: + "\nExpecting " + expected;
0151: throw new ParseException(msg, exp);
0152: }
0153: }
0154:
0155: /**
0156: * Throw an exception if the expression passed in is a literal
0157: * other than of the numerical type
0158: */
0159: private void numberLiteralOnly(Expression exp)
0160: throws ParseException {
0161: notStringLiteral(exp, "number");
0162: notListLiteral(exp, "number");
0163: notHashLiteral(exp, "number");
0164: notBooleanLiteral(exp, "number");
0165: }
0166:
0167: /**
0168: * Throw an exception if the expression passed in is
0169: * not a string.
0170: */
0171: private void stringLiteralOnly(Expression exp)
0172: throws ParseException {
0173: notNumberLiteral(exp, "number");
0174: notListLiteral(exp, "number");
0175: notHashLiteral(exp, "number");
0176: notBooleanLiteral(exp, "number");
0177: }
0178:
0179: /**
0180: * Throw an exception if the expression passed in is a literal
0181: * other than of the boolean type
0182: */
0183: private void booleanLiteralOnly(Expression exp)
0184: throws ParseException {
0185: notStringLiteral(exp, "boolean (true/false)");
0186: notListLiteral(exp, "boolean (true/false)");
0187: notHashLiteral(exp, "boolean (true/false)");
0188: notNumberLiteral(exp, "boolean (true/false)");
0189: }
0190:
0191: private Expression escapedExpression(Expression exp) {
0192: if (!escapes.isEmpty()) {
0193: return ((EscapeBlock) escapes.getFirst()).doEscape(exp);
0194: }
0195: return exp;
0196: }
0197:
0198: private boolean getBoolean(Expression exp) throws ParseException {
0199: TemplateModel tm = null;
0200: try {
0201: tm = exp.getAsTemplateModel(null);
0202: } catch (Exception e) {
0203: throw new ParseException(e.getMessage()
0204: + "\nCould not evaluate expression: "
0205: + exp.getCanonicalForm() + exp.getStartLocation(),
0206: exp);
0207: }
0208: if (tm instanceof TemplateBooleanModel) {
0209: try {
0210: return ((TemplateBooleanModel) tm).getAsBoolean();
0211: } catch (TemplateModelException tme) {
0212: }
0213: }
0214: if (tm instanceof TemplateScalarModel) {
0215: try {
0216: return StringUtil.getYesNo(((TemplateScalarModel) tm)
0217: .getAsString());
0218: } catch (Exception e) {
0219: throw new ParseException(e.getMessage()
0220: + "\nExpecting yes/no, found: "
0221: + exp.getCanonicalForm()
0222: + exp.getStartLocation(), exp);
0223: }
0224: }
0225: throw new ParseException("Expecting boolean (yes/no) parameter"
0226: + exp.getStartLocation(), exp);
0227: }
0228:
0229: // Now the actual parsing code, starting
0230: // with the productions for FreeMarker's
0231: // expression syntax.
0232:
0233: /**
0234: * This is the same as OrExpression, since
0235: * the OR is the operator with the lowest
0236: * precedence.
0237: */
0238: final public Expression Expression() throws ParseException {
0239: Expression exp;
0240: exp = OrExpression();
0241: {
0242: if (true)
0243: return exp;
0244: }
0245: throw new Error("Missing return statement in function");
0246: }
0247:
0248: /**
0249: * Lowest level expression, a literal, a variable,
0250: * or a possibly more complex expression bounded
0251: * by parentheses.
0252: */
0253: final public Expression PrimaryExpression() throws ParseException {
0254: Expression exp;
0255: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0256: case INTEGER:
0257: case DECIMAL:
0258: exp = NumberLiteral();
0259: break;
0260: case OPEN_BRACE:
0261: exp = HashLiteral();
0262: break;
0263: case STRING_LITERAL:
0264: case RAW_STRING:
0265: exp = StringLiteral(true);
0266: break;
0267: case FALSE:
0268: case TRUE:
0269: exp = BooleanLiteral();
0270: break;
0271: case OPEN_BRACKET:
0272: exp = ListLiteral();
0273: break;
0274: case ID:
0275: exp = Identifier();
0276: break;
0277: case OPEN_PAREN:
0278: exp = Parenthesis();
0279: break;
0280: case DOT:
0281: exp = BuiltinVariable();
0282: break;
0283: default:
0284: jj_la1[0] = jj_gen;
0285: jj_consume_token(-1);
0286: throw new ParseException();
0287: }
0288: label_1: while (true) {
0289: if (jj_2_1(2147483647)) {
0290: ;
0291: } else {
0292: break label_1;
0293: }
0294: exp = AddSubExpression(exp);
0295: }
0296: {
0297: if (true)
0298: return exp;
0299: }
0300: throw new Error("Missing return statement in function");
0301: }
0302:
0303: final public Expression Parenthesis() throws ParseException {
0304: Expression exp, result;
0305: Token start, end;
0306: start = jj_consume_token(OPEN_PAREN);
0307: exp = Expression();
0308: end = jj_consume_token(CLOSE_PAREN);
0309: result = new ParentheticalExpression(exp);
0310: result.setLocation(template, start, end);
0311: {
0312: if (true)
0313: return result;
0314: }
0315: throw new Error("Missing return statement in function");
0316: }
0317:
0318: /**
0319: * A primary expression preceded by zero or
0320: * more unary operators. (The only unary operator we
0321: * currently have is the NOT.)
0322: */
0323: final public Expression UnaryExpression() throws ParseException {
0324: Expression exp, result;
0325: boolean haveNot = false;
0326: Token t = null, start = null;
0327: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0328: case PLUS:
0329: case MINUS:
0330: result = UnaryPlusMinusExpression();
0331: break;
0332: case EXCLAM:
0333: result = NotExpression();
0334: break;
0335: case STRING_LITERAL:
0336: case RAW_STRING:
0337: case FALSE:
0338: case TRUE:
0339: case INTEGER:
0340: case DECIMAL:
0341: case DOT:
0342: case OPEN_BRACKET:
0343: case OPEN_PAREN:
0344: case OPEN_BRACE:
0345: case ID:
0346: result = PrimaryExpression();
0347: break;
0348: default:
0349: jj_la1[1] = jj_gen;
0350: jj_consume_token(-1);
0351: throw new ParseException();
0352: }
0353: {
0354: if (true)
0355: return result;
0356: }
0357: throw new Error("Missing return statement in function");
0358: }
0359:
0360: final public Expression NotExpression() throws ParseException {
0361: Token t;
0362: Expression exp, result = null;
0363: ArrayList nots = new ArrayList();
0364: label_2: while (true) {
0365: t = jj_consume_token(EXCLAM);
0366: nots.add(t);
0367: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0368: case EXCLAM:
0369: ;
0370: break;
0371: default:
0372: jj_la1[2] = jj_gen;
0373: break label_2;
0374: }
0375: }
0376: exp = PrimaryExpression();
0377: for (int i = 0; i < nots.size(); i++) {
0378: result = new NotExpression(exp);
0379: Token tok = (Token) nots.get(nots.size() - i - 1);
0380: result.setLocation(template, tok, exp);
0381: exp = result;
0382: }
0383: {
0384: if (true)
0385: return result;
0386: }
0387: throw new Error("Missing return statement in function");
0388: }
0389:
0390: final public Expression UnaryPlusMinusExpression()
0391: throws ParseException {
0392: Expression exp, result;
0393: boolean isMinus = false;
0394: Token t;
0395: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0396: case PLUS:
0397: t = jj_consume_token(PLUS);
0398: break;
0399: case MINUS:
0400: t = jj_consume_token(MINUS);
0401: isMinus = true;
0402: break;
0403: default:
0404: jj_la1[3] = jj_gen;
0405: jj_consume_token(-1);
0406: throw new ParseException();
0407: }
0408: exp = PrimaryExpression();
0409: result = new UnaryPlusMinusExpression(exp, isMinus);
0410: result.setLocation(template, t, exp);
0411: {
0412: if (true)
0413: return result;
0414: }
0415: throw new Error("Missing return statement in function");
0416: }
0417:
0418: final public Expression AdditiveExpression() throws ParseException {
0419: Expression lhs, rhs, result;
0420: boolean plus;
0421: lhs = MultiplicativeExpression();
0422: result = lhs;
0423: label_3: while (true) {
0424: if (jj_2_2(2147483647)) {
0425: ;
0426: } else {
0427: break label_3;
0428: }
0429: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0430: case PLUS:
0431: jj_consume_token(PLUS);
0432: plus = true;
0433: break;
0434: case MINUS:
0435: jj_consume_token(MINUS);
0436: plus = false;
0437: break;
0438: default:
0439: jj_la1[4] = jj_gen;
0440: jj_consume_token(-1);
0441: throw new ParseException();
0442: }
0443: rhs = MultiplicativeExpression();
0444: if (plus) {
0445: // plus is treated separately, since it is also
0446: // used for concatenation.
0447: result = new AddConcatExpression(lhs, rhs);
0448: } else {
0449: numberLiteralOnly(lhs);
0450: numberLiteralOnly(rhs);
0451: result = new ArithmeticExpression(lhs, rhs,
0452: ArithmeticExpression.SUBSTRACTION);
0453: }
0454: result.setLocation(template, lhs, rhs);
0455: lhs = result;
0456: }
0457: {
0458: if (true)
0459: return result;
0460: }
0461: throw new Error("Missing return statement in function");
0462: }
0463:
0464: /**
0465: * A unary expression followed by zero or more
0466: * unary expressions with operators in between.
0467: */
0468: final public Expression MultiplicativeExpression()
0469: throws ParseException {
0470: Expression lhs, rhs, result;
0471: int operation = ArithmeticExpression.MULTIPLICATION;
0472: lhs = UnaryExpression();
0473: result = lhs;
0474: label_4: while (true) {
0475: if (jj_2_3(2147483647)) {
0476: ;
0477: } else {
0478: break label_4;
0479: }
0480: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0481: case TIMES:
0482: jj_consume_token(TIMES);
0483: operation = ArithmeticExpression.MULTIPLICATION;
0484: break;
0485: case DIVIDE:
0486: jj_consume_token(DIVIDE);
0487: operation = ArithmeticExpression.DIVISION;
0488: break;
0489: case PERCENT:
0490: jj_consume_token(PERCENT);
0491: operation = ArithmeticExpression.MODULUS;
0492: break;
0493: default:
0494: jj_la1[5] = jj_gen;
0495: jj_consume_token(-1);
0496: throw new ParseException();
0497: }
0498: rhs = UnaryExpression();
0499: numberLiteralOnly(lhs);
0500: numberLiteralOnly(rhs);
0501: result = new ArithmeticExpression(lhs, rhs, operation);
0502: result.setLocation(template, lhs, rhs);
0503: lhs = result;
0504: }
0505: {
0506: if (true)
0507: return result;
0508: }
0509: throw new Error("Missing return statement in function");
0510: }
0511:
0512: final public Expression EqualityExpression() throws ParseException {
0513: Expression lhs, rhs, result;
0514: Token t;
0515: lhs = RelationalExpression();
0516: result = lhs;
0517: if (jj_2_4(2147483647)) {
0518: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0519: case NOT_EQUALS:
0520: t = jj_consume_token(NOT_EQUALS);
0521: break;
0522: case EQUALS:
0523: t = jj_consume_token(EQUALS);
0524: break;
0525: case DOUBLE_EQUALS:
0526: t = jj_consume_token(DOUBLE_EQUALS);
0527: break;
0528: default:
0529: jj_la1[6] = jj_gen;
0530: jj_consume_token(-1);
0531: throw new ParseException();
0532: }
0533: rhs = RelationalExpression();
0534: notHashLiteral(lhs, "scalar");
0535: notHashLiteral(rhs, "scalar");
0536: notListLiteral(lhs, "scalar");
0537: notListLiteral(rhs, "scalar");
0538: result = new ComparisonExpression(lhs, rhs, t.image);
0539: result.setLocation(template, lhs, rhs);
0540: } else {
0541: ;
0542: }
0543: {
0544: if (true)
0545: return result;
0546: }
0547: throw new Error("Missing return statement in function");
0548: }
0549:
0550: final public Expression RelationalExpression()
0551: throws ParseException {
0552: Expression lhs, rhs, result;
0553: Token t;
0554: lhs = RangeExpression();
0555: result = lhs;
0556: if (jj_2_5(2147483647)) {
0557: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0558: case NATURAL_GTE:
0559: t = jj_consume_token(NATURAL_GTE);
0560: break;
0561: case ESCAPED_GTE:
0562: t = jj_consume_token(ESCAPED_GTE);
0563: break;
0564: case NATURAL_GT:
0565: t = jj_consume_token(NATURAL_GT);
0566: break;
0567: case ESCAPED_GT:
0568: t = jj_consume_token(ESCAPED_GT);
0569: break;
0570: case LESS_THAN_EQUALS:
0571: t = jj_consume_token(LESS_THAN_EQUALS);
0572: break;
0573: case LESS_THAN:
0574: t = jj_consume_token(LESS_THAN);
0575: break;
0576: default:
0577: jj_la1[7] = jj_gen;
0578: jj_consume_token(-1);
0579: throw new ParseException();
0580: }
0581: rhs = RangeExpression();
0582: notHashLiteral(lhs, "scalar");
0583: notHashLiteral(rhs, "scalar");
0584: notListLiteral(lhs, "scalar");
0585: notListLiteral(rhs, "scalar");
0586: notStringLiteral(lhs, "number");
0587: notStringLiteral(rhs, "number");
0588: result = new ComparisonExpression(lhs, rhs, t.image);
0589: result.setLocation(template, lhs, rhs);
0590: } else {
0591: ;
0592: }
0593: {
0594: if (true)
0595: return result;
0596: }
0597: throw new Error("Missing return statement in function");
0598: }
0599:
0600: final public Expression RangeExpression() throws ParseException {
0601: Expression lhs, rhs = null, result;
0602: lhs = AdditiveExpression();
0603: result = lhs;
0604: if (jj_2_7(2147483647)) {
0605: jj_consume_token(DOT_DOT);
0606: if (jj_2_6(2147483647)) {
0607: rhs = AdditiveExpression();
0608: } else {
0609: ;
0610: }
0611: numberLiteralOnly(lhs);
0612: if (rhs != null) {
0613: numberLiteralOnly(rhs);
0614: }
0615: Range range = new Range(lhs, rhs);
0616: if (rhs != null) {
0617: range.setLocation(template, lhs, rhs);
0618: } else {
0619: range.setLocation(template, lhs, lhs);
0620: }
0621: result = range;
0622: } else {
0623: ;
0624: }
0625: {
0626: if (true)
0627: return result;
0628: }
0629: throw new Error("Missing return statement in function");
0630: }
0631:
0632: final public Expression AndExpression() throws ParseException {
0633: Expression lhs, rhs, result;
0634: lhs = EqualityExpression();
0635: result = lhs;
0636: label_5: while (true) {
0637: if (jj_2_8(2147483647)) {
0638: ;
0639: } else {
0640: break label_5;
0641: }
0642: jj_consume_token(AND);
0643: rhs = EqualityExpression();
0644: booleanLiteralOnly(lhs);
0645: booleanLiteralOnly(rhs);
0646: result = new AndExpression(lhs, rhs);
0647: result.setLocation(template, lhs, rhs);
0648: lhs = result;
0649: }
0650: {
0651: if (true)
0652: return result;
0653: }
0654: throw new Error("Missing return statement in function");
0655: }
0656:
0657: final public Expression OrExpression() throws ParseException {
0658: Expression lhs, rhs, result;
0659: lhs = AndExpression();
0660: result = lhs;
0661: label_6: while (true) {
0662: if (jj_2_9(2147483647)) {
0663: ;
0664: } else {
0665: break label_6;
0666: }
0667: jj_consume_token(OR);
0668: rhs = AndExpression();
0669: booleanLiteralOnly(lhs);
0670: booleanLiteralOnly(rhs);
0671: result = new OrExpression(lhs, rhs);
0672: result.setLocation(template, lhs, rhs);
0673: lhs = result;
0674: }
0675: {
0676: if (true)
0677: return result;
0678: }
0679: throw new Error("Missing return statement in function");
0680: }
0681:
0682: final public ListLiteral ListLiteral() throws ParseException {
0683: ArrayList values = new ArrayList();
0684: Token begin, end;
0685: begin = jj_consume_token(OPEN_BRACKET);
0686: values = PositionalArgs();
0687: end = jj_consume_token(CLOSE_BRACKET);
0688: ListLiteral result = new ListLiteral(values);
0689: result.setLocation(template, begin, end);
0690: {
0691: if (true)
0692: return result;
0693: }
0694: throw new Error("Missing return statement in function");
0695: }
0696:
0697: final public Expression NumberLiteral() throws ParseException {
0698: Token op = null, t;
0699: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0700: case INTEGER:
0701: t = jj_consume_token(INTEGER);
0702: break;
0703: case DECIMAL:
0704: t = jj_consume_token(DECIMAL);
0705: break;
0706: default:
0707: jj_la1[8] = jj_gen;
0708: jj_consume_token(-1);
0709: throw new ParseException();
0710: }
0711: String s = t.image;
0712: Expression result = new NumberLiteral(template
0713: .getArithmeticEngine().toNumber(s));
0714: Token startToken = (op != null) ? op : t;
0715: result.setLocation(template, startToken, t);
0716: {
0717: if (true)
0718: return result;
0719: }
0720: throw new Error("Missing return statement in function");
0721: }
0722:
0723: final public Identifier Identifier() throws ParseException {
0724: Token t;
0725: t = jj_consume_token(ID);
0726: Identifier id = new Identifier(t.image);
0727: id.setLocation(template, t, t);
0728: {
0729: if (true)
0730: return id;
0731: }
0732: throw new Error("Missing return statement in function");
0733: }
0734:
0735: final public Expression IdentifierOrStringLiteral()
0736: throws ParseException {
0737: Expression exp;
0738: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0739: case ID:
0740: exp = Identifier();
0741: break;
0742: case STRING_LITERAL:
0743: case RAW_STRING:
0744: exp = StringLiteral(false);
0745: break;
0746: default:
0747: jj_la1[9] = jj_gen;
0748: jj_consume_token(-1);
0749: throw new ParseException();
0750: }
0751: {
0752: if (true)
0753: return exp;
0754: }
0755: throw new Error("Missing return statement in function");
0756: }
0757:
0758: final public BuiltinVariable BuiltinVariable()
0759: throws ParseException {
0760: Token dot, name;
0761: dot = jj_consume_token(DOT);
0762: name = jj_consume_token(ID);
0763: BuiltinVariable result = null;
0764: try {
0765: result = new BuiltinVariable(name.image);
0766: } catch (ParseException pe) {
0767: pe.lineNumber = dot.beginLine;
0768: pe.columnNumber = dot.beginColumn;
0769: {
0770: if (true)
0771: throw pe;
0772: }
0773: }
0774: result.setLocation(template, dot, name);
0775: {
0776: if (true)
0777: return result;
0778: }
0779: throw new Error("Missing return statement in function");
0780: }
0781:
0782: /**
0783: * Production that builds up an expression
0784: * using the dot or dynamic key name
0785: * or the args list if this is a method invocation.
0786: */
0787: final public Expression AddSubExpression(Expression exp)
0788: throws ParseException {
0789: Expression result = null;
0790: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0791: case DOT:
0792: result = DotVariable(exp);
0793: break;
0794: case OPEN_BRACKET:
0795: result = DynamicKey(exp);
0796: break;
0797: case OPEN_PAREN:
0798: result = MethodArgs(exp);
0799: break;
0800: case BUILT_IN:
0801: result = BuiltIn(exp);
0802: break;
0803: case EXCLAM:
0804: result = DefaultTo(exp);
0805: break;
0806: case EXISTS:
0807: result = Exists(exp);
0808: break;
0809: default:
0810: jj_la1[10] = jj_gen;
0811: jj_consume_token(-1);
0812: throw new ParseException();
0813: }
0814: {
0815: if (true)
0816: return result;
0817: }
0818: throw new Error("Missing return statement in function");
0819: }
0820:
0821: final public Expression DefaultTo(Expression exp)
0822: throws ParseException {
0823: Expression rhs = null;
0824: Token t;
0825: t = jj_consume_token(EXCLAM);
0826: if (jj_2_10(2147483647)) {
0827: rhs = Expression();
0828: } else {
0829: ;
0830: }
0831: DefaultToExpression result = new DefaultToExpression(exp, rhs);
0832: if (rhs == null) {
0833: result.setLocation(template, exp, t);
0834: } else {
0835: result.setLocation(template, exp, rhs);
0836: }
0837: {
0838: if (true)
0839: return result;
0840: }
0841: throw new Error("Missing return statement in function");
0842: }
0843:
0844: final public Expression Exists(Expression exp)
0845: throws ParseException {
0846: Token t;
0847: t = jj_consume_token(EXISTS);
0848: ExistsExpression result = new ExistsExpression(exp);
0849: result.setLocation(template, exp, t);
0850: {
0851: if (true)
0852: return result;
0853: }
0854: throw new Error("Missing return statement in function");
0855: }
0856:
0857: final public Expression BuiltIn(Expression exp)
0858: throws ParseException {
0859: Token t = null;
0860: jj_consume_token(BUILT_IN);
0861: t = jj_consume_token(ID);
0862: BuiltIn result = null;
0863: try {
0864: result = BuiltIn.newBuiltIn(exp, t.image, t, templateName);
0865: } catch (ParseException pe) {
0866: pe.lineNumber = t.beginLine;
0867: pe.columnNumber = t.beginColumn;
0868: {
0869: if (true)
0870: throw pe;
0871: }
0872: }
0873: result.setLocation(template, exp, t);
0874: {
0875: if (true)
0876: return result;
0877: }
0878: throw new Error("Missing return statement in function");
0879: }
0880:
0881: /**
0882: * production for when a key is specified by <DOT> + keyname
0883: */
0884: final public Expression DotVariable(Expression exp)
0885: throws ParseException {
0886: Token t;
0887: jj_consume_token(DOT);
0888: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0889: case ID:
0890: t = jj_consume_token(ID);
0891: break;
0892: case TIMES:
0893: t = jj_consume_token(TIMES);
0894: break;
0895: case DOUBLE_STAR:
0896: t = jj_consume_token(DOUBLE_STAR);
0897: break;
0898: case FALSE:
0899: case TRUE:
0900: case LESS_THAN:
0901: case LESS_THAN_EQUALS:
0902: case ESCAPED_GT:
0903: case ESCAPED_GTE:
0904: case IN:
0905: case AS:
0906: case USING:
0907: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0908: case LESS_THAN:
0909: t = jj_consume_token(LESS_THAN);
0910: break;
0911: case LESS_THAN_EQUALS:
0912: t = jj_consume_token(LESS_THAN_EQUALS);
0913: break;
0914: case ESCAPED_GT:
0915: t = jj_consume_token(ESCAPED_GT);
0916: break;
0917: case ESCAPED_GTE:
0918: t = jj_consume_token(ESCAPED_GTE);
0919: break;
0920: case FALSE:
0921: t = jj_consume_token(FALSE);
0922: break;
0923: case TRUE:
0924: t = jj_consume_token(TRUE);
0925: break;
0926: case IN:
0927: t = jj_consume_token(IN);
0928: break;
0929: case AS:
0930: t = jj_consume_token(AS);
0931: break;
0932: case USING:
0933: t = jj_consume_token(USING);
0934: break;
0935: default:
0936: jj_la1[11] = jj_gen;
0937: jj_consume_token(-1);
0938: throw new ParseException();
0939: }
0940: if (!Character.isLetter(t.image.charAt(0))) {
0941: String msg = getErrorStart(t) + "\n" + t.image
0942: + " is not a valid identifier.";
0943: {
0944: if (true)
0945: throw new ParseException(msg, t.beginLine,
0946: t.beginColumn);
0947: }
0948: }
0949: break;
0950: default:
0951: jj_la1[12] = jj_gen;
0952: jj_consume_token(-1);
0953: throw new ParseException();
0954: }
0955: notListLiteral(exp, "hash");
0956: notStringLiteral(exp, "hash");
0957: notBooleanLiteral(exp, "hash");
0958: Dot dot = new Dot(exp, t.image);
0959: dot.setLocation(template, exp, t);
0960: {
0961: if (true)
0962: return dot;
0963: }
0964: throw new Error("Missing return statement in function");
0965: }
0966:
0967: /**
0968: * production for when the key is specified
0969: * in brackets.
0970: */
0971: final public Expression DynamicKey(Expression exp)
0972: throws ParseException {
0973: Expression arg;
0974: Token t;
0975: jj_consume_token(OPEN_BRACKET);
0976: arg = Expression();
0977: t = jj_consume_token(CLOSE_BRACKET);
0978: notBooleanLiteral(exp, "list or hash");
0979: notNumberLiteral(exp, "list or hash");
0980: DynamicKeyName dkn = new DynamicKeyName(exp, arg);
0981: dkn.setLocation(template, exp, t);
0982: {
0983: if (true)
0984: return dkn;
0985: }
0986: throw new Error("Missing return statement in function");
0987: }
0988:
0989: /**
0990: * production for an arglist part of a method invocation.
0991: */
0992: final public MethodCall MethodArgs(Expression exp)
0993: throws ParseException {
0994: ArrayList args = new ArrayList();
0995: Token end;
0996: jj_consume_token(OPEN_PAREN);
0997: args = PositionalArgs();
0998: end = jj_consume_token(CLOSE_PAREN);
0999: args.trimToSize();
1000: MethodCall result = new MethodCall(exp, args);
1001: result.setLocation(template, exp, end);
1002: {
1003: if (true)
1004: return result;
1005: }
1006: throw new Error("Missing return statement in function");
1007: }
1008:
1009: final public StringLiteral StringLiteral(boolean interpolate)
1010: throws ParseException {
1011: Token t;
1012: boolean raw = false;
1013: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1014: case STRING_LITERAL:
1015: t = jj_consume_token(STRING_LITERAL);
1016: break;
1017: case RAW_STRING:
1018: t = jj_consume_token(RAW_STRING);
1019: raw = true;
1020: break;
1021: default:
1022: jj_la1[13] = jj_gen;
1023: jj_consume_token(-1);
1024: throw new ParseException();
1025: }
1026: String s = t.image;
1027: // Get rid of the quotes.
1028: s = s.substring(1, s.length() - 1);
1029: if (raw) {
1030: s = s.substring(1);
1031: } else
1032: try {
1033: s = StringUtil.FTLStringLiteralDec(s);
1034: } catch (ParseException pe) {
1035: pe.lineNumber = t.beginLine;
1036: pe.columnNumber = t.beginColumn;
1037: {
1038: if (true)
1039: throw pe;
1040: }
1041: }
1042: StringLiteral result = new StringLiteral(s);
1043: result.setLocation(template, t, t);
1044: if (interpolate && !raw) {
1045: result.checkInterpolation();
1046: }
1047: {
1048: if (true)
1049: return result;
1050: }
1051: throw new Error("Missing return statement in function");
1052: }
1053:
1054: final public Expression BooleanLiteral() throws ParseException {
1055: Token t;
1056: Expression result;
1057: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1058: case FALSE:
1059: t = jj_consume_token(FALSE);
1060: result = new BooleanLiteral(false);
1061: break;
1062: case TRUE:
1063: t = jj_consume_token(TRUE);
1064: result = new BooleanLiteral(true);
1065: break;
1066: default:
1067: jj_la1[14] = jj_gen;
1068: jj_consume_token(-1);
1069: throw new ParseException();
1070: }
1071: result.setLocation(template, t, t);
1072: {
1073: if (true)
1074: return result;
1075: }
1076: throw new Error("Missing return statement in function");
1077: }
1078:
1079: final public HashLiteral HashLiteral() throws ParseException {
1080: Token begin, end;
1081: Expression key, value;
1082: ArrayList keys = new ArrayList();
1083: ArrayList values = new ArrayList();
1084: begin = jj_consume_token(OPEN_BRACE);
1085: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1086: case STRING_LITERAL:
1087: case RAW_STRING:
1088: case FALSE:
1089: case TRUE:
1090: case INTEGER:
1091: case DECIMAL:
1092: case DOT:
1093: case PLUS:
1094: case MINUS:
1095: case EXCLAM:
1096: case OPEN_BRACKET:
1097: case OPEN_PAREN:
1098: case OPEN_BRACE:
1099: case ID:
1100: key = Expression();
1101: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1102: case COMMA:
1103: jj_consume_token(COMMA);
1104: break;
1105: case COLON:
1106: jj_consume_token(COLON);
1107: break;
1108: default:
1109: jj_la1[15] = jj_gen;
1110: jj_consume_token(-1);
1111: throw new ParseException();
1112: }
1113: value = Expression();
1114: stringLiteralOnly(key);
1115: keys.add(key);
1116: values.add(value);
1117: label_7: while (true) {
1118: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1119: case COMMA:
1120: ;
1121: break;
1122: default:
1123: jj_la1[16] = jj_gen;
1124: break label_7;
1125: }
1126: jj_consume_token(COMMA);
1127: key = Expression();
1128: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1129: case COMMA:
1130: jj_consume_token(COMMA);
1131: break;
1132: case COLON:
1133: jj_consume_token(COLON);
1134: break;
1135: default:
1136: jj_la1[17] = jj_gen;
1137: jj_consume_token(-1);
1138: throw new ParseException();
1139: }
1140: value = Expression();
1141: stringLiteralOnly(key);
1142: keys.add(key);
1143: values.add(value);
1144: }
1145: break;
1146: default:
1147: jj_la1[18] = jj_gen;
1148: ;
1149: }
1150: end = jj_consume_token(CLOSE_BRACE);
1151: HashLiteral result = new HashLiteral(keys, values);
1152: result.setLocation(template, begin, end);
1153: {
1154: if (true)
1155: return result;
1156: }
1157: throw new Error("Missing return statement in function");
1158: }
1159:
1160: /**
1161: * A production representing the ${...}
1162: * that outputs a variable.
1163: */
1164: final public DollarVariable StringOutput() throws ParseException {
1165: Expression exp;
1166: Token begin, end;
1167: begin = jj_consume_token(OUTPUT_ESCAPE);
1168: exp = Expression();
1169: notHashLiteral(exp, "scalar");
1170: notListLiteral(exp, "scalar");
1171: notBooleanLiteral(exp, "scalar");
1172: end = jj_consume_token(CLOSE_BRACE);
1173: DollarVariable result = new DollarVariable(exp,
1174: escapedExpression(exp));
1175: result.setLocation(template, begin, end);
1176: {
1177: if (true)
1178: return result;
1179: }
1180: throw new Error("Missing return statement in function");
1181: }
1182:
1183: final public NumericalOutput NumericalOutput()
1184: throws ParseException {
1185: Expression exp;
1186: Token fmt = null, begin, end;
1187: begin = jj_consume_token(NUMERICAL_ESCAPE);
1188: exp = Expression();
1189: numberLiteralOnly(exp);
1190: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1191: case SEMICOLON:
1192: jj_consume_token(SEMICOLON);
1193: fmt = jj_consume_token(ID);
1194: break;
1195: default:
1196: jj_la1[19] = jj_gen;
1197: ;
1198: }
1199: end = jj_consume_token(CLOSE_BRACE);
1200: NumericalOutput result;
1201: if (fmt != null) {
1202: int minFrac = -1; // -1 indicates that the value has not been set
1203: int maxFrac = -1;
1204:
1205: StringTokenizer st = new StringTokenizer(fmt.image, "mM",
1206: true);
1207: char type = '-';
1208: while (st.hasMoreTokens()) {
1209: String token = st.nextToken();
1210: try {
1211: if (type != '-') {
1212: switch (type) {
1213: case 'm':
1214: if (minFrac != -1) {
1215: if (true)
1216: throw new ParseException(
1217: "invalid formatting string",
1218: fmt.beginLine,
1219: fmt.beginColumn);
1220: }
1221: minFrac = Integer.parseInt(token);
1222: break;
1223: case 'M':
1224: if (maxFrac != -1) {
1225: if (true)
1226: throw new ParseException(
1227: "invalid formatting string",
1228: fmt.beginLine,
1229: fmt.beginColumn);
1230: }
1231: maxFrac = Integer.parseInt(token);
1232: break;
1233: default: {
1234: if (true)
1235: throw new ParseException();
1236: }
1237: }
1238: type = '-';
1239: } else if (token.equals("m")) {
1240: type = 'm';
1241: } else if (token.equals("M")) {
1242: type = 'M';
1243: } else {
1244: {
1245: if (true)
1246: throw new ParseException();
1247: }
1248: }
1249: } catch (ParseException e) {
1250: String msg = getErrorStart(fmt)
1251: + "\nInvalid format specifier " + fmt.image;
1252: {
1253: if (true)
1254: throw new ParseException(msg,
1255: fmt.beginLine, fmt.beginColumn);
1256: }
1257: } catch (NumberFormatException e) {
1258: String msg = getErrorStart(fmt)
1259: + "\nInvalid number in the format specifier "
1260: + fmt.image;
1261: {
1262: if (true)
1263: throw new ParseException(msg,
1264: fmt.beginLine, fmt.beginColumn);
1265: }
1266: }
1267: }
1268:
1269: if (maxFrac == -1) {
1270: if (minFrac == -1) {
1271: String msg = getErrorStart(fmt)
1272: + "\nInvalid format specification, at least one of m and M must be specified!";
1273: {
1274: if (true)
1275: throw new ParseException(msg,
1276: fmt.beginLine, fmt.beginColumn);
1277: }
1278: }
1279: maxFrac = minFrac;
1280: } else if (minFrac == -1) {
1281: minFrac = 0;
1282: }
1283: if (minFrac > maxFrac) {
1284: String msg = getErrorStart(fmt)
1285: + "\nInvalid format specification, min cannot be greater than max!";
1286: {
1287: if (true)
1288: throw new ParseException(msg, fmt.beginLine,
1289: fmt.beginColumn);
1290: }
1291: }
1292: if (minFrac > 50 || maxFrac > 50) {// sanity check
1293: String msg = getErrorStart(fmt)
1294: + "\nCannot specify more than 50 fraction digits";
1295: {
1296: if (true)
1297: throw new ParseException(msg, fmt.beginLine,
1298: fmt.beginColumn);
1299: }
1300: }
1301: result = new NumericalOutput(exp, minFrac, maxFrac);
1302: } else { // if format != null
1303: result = new NumericalOutput(exp);
1304: }
1305: result.setLocation(template, begin, end);
1306: {
1307: if (true)
1308: return result;
1309: }
1310: throw new Error("Missing return statement in function");
1311: }
1312:
1313: final public TemplateElement If() throws ParseException {
1314: Token start, end, t;
1315: Expression condition;
1316: TemplateElement block;
1317: IfBlock ifBlock;
1318: ConditionalBlock cblock;
1319: start = jj_consume_token(IF);
1320: condition = Expression();
1321: jj_consume_token(DIRECTIVE_END);
1322: block = OptionalBlock();
1323: cblock = new ConditionalBlock(condition, block, true);
1324: cblock.setLocation(template, start, block);
1325: ifBlock = new IfBlock(cblock);
1326: label_8: while (true) {
1327: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1328: case ELSE_IF:
1329: ;
1330: break;
1331: default:
1332: jj_la1[20] = jj_gen;
1333: break label_8;
1334: }
1335: t = jj_consume_token(ELSE_IF);
1336: condition = Expression();
1337: LooseDirectiveEnd();
1338: block = OptionalBlock();
1339: cblock = new ConditionalBlock(condition, block, false);
1340: cblock.setLocation(template, t, block);
1341: ifBlock.addBlock(cblock);
1342: }
1343: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1344: case ELSE:
1345: t = jj_consume_token(ELSE);
1346: block = OptionalBlock();
1347: cblock = new ConditionalBlock(null, block, false);
1348: cblock.setLocation(template, t, block);
1349: ifBlock.addBlock(cblock);
1350: break;
1351: default:
1352: jj_la1[21] = jj_gen;
1353: ;
1354: }
1355: end = jj_consume_token(END_IF);
1356: ifBlock.setLocation(template, start, end);
1357: {
1358: if (true)
1359: return ifBlock;
1360: }
1361: throw new Error("Missing return statement in function");
1362: }
1363:
1364: final public AttemptBlock Attempt() throws ParseException {
1365: Token start, end;
1366: TemplateElement block, recoveryBlock;
1367: start = jj_consume_token(ATTEMPT);
1368: block = OptionalBlock();
1369: recoveryBlock = Recover();
1370: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1371: case END_RECOVER:
1372: end = jj_consume_token(END_RECOVER);
1373: break;
1374: case END_ATTEMPT:
1375: end = jj_consume_token(END_ATTEMPT);
1376: break;
1377: default:
1378: jj_la1[22] = jj_gen;
1379: jj_consume_token(-1);
1380: throw new ParseException();
1381: }
1382: AttemptBlock result = new AttemptBlock(block, recoveryBlock);
1383: result.setLocation(template, start, end);
1384: {
1385: if (true)
1386: return result;
1387: }
1388: throw new Error("Missing return statement in function");
1389: }
1390:
1391: final public RecoveryBlock Recover() throws ParseException {
1392: Token start;
1393: TemplateElement block;
1394: start = jj_consume_token(RECOVER);
1395: block = OptionalBlock();
1396: RecoveryBlock result = new RecoveryBlock(block);
1397: result.setLocation(template, start, block);
1398: {
1399: if (true)
1400: return result;
1401: }
1402: throw new Error("Missing return statement in function");
1403: }
1404:
1405: final public IteratorBlock List() throws ParseException {
1406: Expression exp;
1407: Token index, start, end;
1408: TemplateElement block;
1409: start = jj_consume_token(LIST);
1410: ++loopNesting;
1411: exp = Expression();
1412: jj_consume_token(AS);
1413: index = jj_consume_token(ID);
1414: jj_consume_token(DIRECTIVE_END);
1415: block = OptionalBlock();
1416: end = jj_consume_token(END_LIST);
1417: --loopNesting;
1418: IteratorBlock result = new IteratorBlock(exp, index.image,
1419: block, false);
1420: result.setLocation(template, start, end);
1421: {
1422: if (true)
1423: return result;
1424: }
1425: throw new Error("Missing return statement in function");
1426: }
1427:
1428: final public IteratorBlock ForEach() throws ParseException {
1429: Expression exp;
1430: Token index, start, end;
1431: TemplateElement block;
1432: start = jj_consume_token(FOREACH);
1433: ++loopNesting;
1434: index = jj_consume_token(ID);
1435: jj_consume_token(IN);
1436: exp = Expression();
1437: jj_consume_token(DIRECTIVE_END);
1438: block = OptionalBlock();
1439: end = jj_consume_token(END_FOREACH);
1440: --loopNesting;
1441: IteratorBlock result = new IteratorBlock(exp, index.image,
1442: block, true);
1443: result.setLocation(template, start, end);
1444: {
1445: if (true)
1446: return result;
1447: }
1448: throw new Error("Missing return statement in function");
1449: }
1450:
1451: final public VisitNode Visit() throws ParseException {
1452: Token start, end;
1453: Expression targetNode, namespaces = null;
1454: start = jj_consume_token(VISIT);
1455: targetNode = Expression();
1456: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1457: case USING:
1458: jj_consume_token(USING);
1459: namespaces = Expression();
1460: break;
1461: default:
1462: jj_la1[23] = jj_gen;
1463: ;
1464: }
1465: end = LooseDirectiveEnd();
1466: VisitNode result = new VisitNode(targetNode, namespaces);
1467: result.setLocation(template, start, end);
1468: {
1469: if (true)
1470: return result;
1471: }
1472: throw new Error("Missing return statement in function");
1473: }
1474:
1475: final public RecurseNode Recurse() throws ParseException {
1476: Token start, end = null;
1477: Expression node = null, namespaces = null;
1478: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1479: case SIMPLE_RECURSE:
1480: start = jj_consume_token(SIMPLE_RECURSE);
1481: break;
1482: case RECURSE:
1483: start = jj_consume_token(RECURSE);
1484: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1485: case STRING_LITERAL:
1486: case RAW_STRING:
1487: case FALSE:
1488: case TRUE:
1489: case INTEGER:
1490: case DECIMAL:
1491: case DOT:
1492: case PLUS:
1493: case MINUS:
1494: case EXCLAM:
1495: case OPEN_BRACKET:
1496: case OPEN_PAREN:
1497: case OPEN_BRACE:
1498: case ID:
1499: node = Expression();
1500: break;
1501: default:
1502: jj_la1[24] = jj_gen;
1503: ;
1504: }
1505: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1506: case USING:
1507: jj_consume_token(USING);
1508: namespaces = Expression();
1509: break;
1510: default:
1511: jj_la1[25] = jj_gen;
1512: ;
1513: }
1514: end = LooseDirectiveEnd();
1515: break;
1516: default:
1517: jj_la1[26] = jj_gen;
1518: jj_consume_token(-1);
1519: throw new ParseException();
1520: }
1521: if (end == null)
1522: end = start;
1523: RecurseNode result = new RecurseNode(node, namespaces);
1524: result.setLocation(template, start, end);
1525: {
1526: if (true)
1527: return result;
1528: }
1529: throw new Error("Missing return statement in function");
1530: }
1531:
1532: final public FallbackInstruction FallBack() throws ParseException {
1533: Token tok;
1534: tok = jj_consume_token(FALLBACK);
1535: if (!inMacro) {
1536: {
1537: if (true)
1538: throw new ParseException(getErrorStart(tok)
1539: + "\nCannot fall back "
1540: + " outside a macro.", tok.beginLine,
1541: tok.beginColumn);
1542: }
1543:
1544: }
1545: FallbackInstruction result = new FallbackInstruction();
1546: result.setLocation(template, tok, tok);
1547: {
1548: if (true)
1549: return result;
1550: }
1551: throw new Error("Missing return statement in function");
1552: }
1553:
1554: /**
1555: * Production used to break out of a loop or a switch block.
1556: */
1557: final public BreakInstruction Break() throws ParseException {
1558: Token start;
1559: start = jj_consume_token(BREAK);
1560: if (loopNesting < 1 && switchNesting < 1) {
1561: String msg = getErrorStart(start) + "\n" + start.image
1562: + " occurred outside a loop or a switch block.";
1563: {
1564: if (true)
1565: throw new ParseException(msg, start.beginLine,
1566: start.beginColumn);
1567: }
1568: }
1569: BreakInstruction result = new BreakInstruction();
1570: result.setLocation(template, start, start);
1571: {
1572: if (true)
1573: return result;
1574: }
1575: throw new Error("Missing return statement in function");
1576: }
1577:
1578: /**
1579: * Production used to jump out of a macro.
1580: * The stop instruction terminates the rendering of the template.
1581: */
1582: final public ReturnInstruction Return() throws ParseException {
1583: Token start, end = null;
1584: Expression exp = null;
1585: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1586: case SIMPLE_RETURN:
1587: start = jj_consume_token(SIMPLE_RETURN);
1588: end = start;
1589: break;
1590: case RETURN:
1591: start = jj_consume_token(RETURN);
1592: exp = Expression();
1593: end = LooseDirectiveEnd();
1594: break;
1595: default:
1596: jj_la1[27] = jj_gen;
1597: jj_consume_token(-1);
1598: throw new ParseException();
1599: }
1600: if (inMacro) {
1601: if (exp != null) {
1602: String msg = getErrorStart(start)
1603: + "\nA macro cannot return a value";
1604: {
1605: if (true)
1606: throw new ParseException(msg, start.beginLine,
1607: start.beginColumn);
1608: }
1609: }
1610: } else if (inFunction) {
1611: if (exp == null) {
1612: String msg = getErrorStart(start)
1613: + "\nA function must return a value";
1614: {
1615: if (true)
1616: throw new ParseException(msg, start.beginLine,
1617: start.beginColumn);
1618: }
1619: }
1620: } else {
1621: if (exp == null) {
1622: String msg = getErrorStart(start)
1623: + "\nA return instruction can only occur inside a macro of function";
1624: {
1625: if (true)
1626: throw new ParseException(msg, start.beginLine,
1627: start.beginColumn);
1628: }
1629: }
1630: }
1631: ReturnInstruction result = new ReturnInstruction(exp);
1632: result.setLocation(template, start, end);
1633: {
1634: if (true)
1635: return result;
1636: }
1637: throw new Error("Missing return statement in function");
1638: }
1639:
1640: final public StopInstruction Stop() throws ParseException {
1641: Token start = null;
1642: Expression exp = null;
1643: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1644: case HALT:
1645: start = jj_consume_token(HALT);
1646: break;
1647: case STOP:
1648: start = jj_consume_token(STOP);
1649: exp = Expression();
1650: LooseDirectiveEnd();
1651: break;
1652: default:
1653: jj_la1[28] = jj_gen;
1654: jj_consume_token(-1);
1655: throw new ParseException();
1656: }
1657: StopInstruction result = new StopInstruction(exp);
1658: result.setLocation(template, start, start);
1659: {
1660: if (true)
1661: return result;
1662: }
1663: throw new Error("Missing return statement in function");
1664: }
1665:
1666: final public TemplateElement Nested() throws ParseException {
1667: Token t, end;
1668: ArrayList bodyParameters;
1669: BodyInstruction result = null;
1670: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1671: case SIMPLE_NESTED:
1672: t = jj_consume_token(SIMPLE_NESTED);
1673: result = new BodyInstruction(null);
1674: result.setLocation(template, t, t);
1675: break;
1676: case NESTED:
1677: t = jj_consume_token(NESTED);
1678: bodyParameters = PositionalArgs();
1679: end = LooseDirectiveEnd();
1680: result = new BodyInstruction(bodyParameters);
1681: result.setLocation(template, t, end);
1682: break;
1683: default:
1684: jj_la1[29] = jj_gen;
1685: jj_consume_token(-1);
1686: throw new ParseException();
1687: }
1688: if (!inMacro) {
1689: {
1690: if (true)
1691: throw new ParseException(getErrorStart(t)
1692: + "\nCannot use a " + t.image
1693: + " instruction outside a macro.",
1694: t.beginLine, t.beginColumn);
1695: }
1696: }
1697: {
1698: if (true)
1699: return result;
1700: }
1701: throw new Error("Missing return statement in function");
1702: }
1703:
1704: final public TemplateElement Flush() throws ParseException {
1705: Token t;
1706: t = jj_consume_token(FLUSH);
1707: FlushInstruction result = new FlushInstruction();
1708: result.setLocation(template, t, t);
1709: {
1710: if (true)
1711: return result;
1712: }
1713: throw new Error("Missing return statement in function");
1714: }
1715:
1716: final public TemplateElement Trim() throws ParseException {
1717: Token t;
1718: TrimInstruction result = null;
1719: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1720: case TRIM:
1721: t = jj_consume_token(TRIM);
1722: result = new TrimInstruction(true, true);
1723: break;
1724: case LTRIM:
1725: t = jj_consume_token(LTRIM);
1726: result = new TrimInstruction(true, false);
1727: break;
1728: case RTRIM:
1729: t = jj_consume_token(RTRIM);
1730: result = new TrimInstruction(false, true);
1731: break;
1732: case NOTRIM:
1733: t = jj_consume_token(NOTRIM);
1734: result = new TrimInstruction(false, false);
1735: break;
1736: default:
1737: jj_la1[30] = jj_gen;
1738: jj_consume_token(-1);
1739: throw new ParseException();
1740: }
1741: result.setLocation(template, t, t);
1742: {
1743: if (true)
1744: return result;
1745: }
1746: throw new Error("Missing return statement in function");
1747: }
1748:
1749: final public TemplateElement Assign() throws ParseException {
1750: Token start, end;
1751: int scope;
1752: Token id = null;
1753: Expression nameExp, exp, nsExp = null;
1754: String varName;
1755: ArrayList assignments = new ArrayList();
1756: Assignment ass;
1757: TemplateElement block;
1758: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1759: case ASSIGN:
1760: start = jj_consume_token(ASSIGN);
1761: scope = Assignment.NAMESPACE;
1762: break;
1763: case GLOBALASSIGN:
1764: start = jj_consume_token(GLOBALASSIGN);
1765: scope = Assignment.GLOBAL;
1766: break;
1767: case LOCALASSIGN:
1768: start = jj_consume_token(LOCALASSIGN);
1769: scope = Assignment.LOCAL;
1770: scope = Assignment.LOCAL;
1771: if (!inMacro && !inFunction) {
1772: String msg = getErrorStart(start)
1773: + "\nLocal variable assigned outside a macro.";
1774: {
1775: if (true)
1776: throw new ParseException(msg, start.beginLine,
1777: start.beginColumn);
1778: }
1779: }
1780: break;
1781: default:
1782: jj_la1[31] = jj_gen;
1783: jj_consume_token(-1);
1784: throw new ParseException();
1785: }
1786: nameExp = IdentifierOrStringLiteral();
1787: varName = (nameExp instanceof StringLiteral) ? ((StringLiteral) nameExp)
1788: .getAsString()
1789: : nameExp.toString();
1790: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1791: case EQUALS:
1792: jj_consume_token(EQUALS);
1793: exp = Expression();
1794: ass = new Assignment(varName, exp, scope);
1795: ass.setLocation(template, nameExp, exp);
1796: assignments.add(ass);
1797: label_9: while (true) {
1798: if (jj_2_11(2147483647)) {
1799: ;
1800: } else {
1801: break label_9;
1802: }
1803: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1804: case COMMA:
1805: jj_consume_token(COMMA);
1806: break;
1807: default:
1808: jj_la1[32] = jj_gen;
1809: ;
1810: }
1811: nameExp = IdentifierOrStringLiteral();
1812: varName = (nameExp instanceof StringLiteral) ? ((StringLiteral) nameExp)
1813: .getAsString()
1814: : nameExp.toString();
1815: jj_consume_token(EQUALS);
1816: exp = Expression();
1817: ass = new Assignment(varName, exp, scope);
1818: ass.setLocation(template, nameExp, exp);
1819: assignments.add(ass);
1820: }
1821: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1822: case IN:
1823: id = jj_consume_token(IN);
1824: nsExp = Expression();
1825: if (scope != Assignment.NAMESPACE) {
1826: if (true)
1827: throw new ParseException(getErrorStart(id)
1828: + "\nCannot assign to namespace here.",
1829: id.beginLine, id.beginColumn);
1830: }
1831: break;
1832: default:
1833: jj_la1[33] = jj_gen;
1834: ;
1835: }
1836: end = LooseDirectiveEnd();
1837: AssignmentInstruction ai = new AssignmentInstruction(scope);
1838: for (int i = 0; i < assignments.size(); i++) {
1839: ai.addAssignment((Assignment) assignments.get(i));
1840: }
1841: ai.setNamespaceExp(nsExp);
1842: ai.setLocation(template, start, end);
1843: {
1844: if (true)
1845: return ai;
1846: }
1847: break;
1848: case IN:
1849: case DIRECTIVE_END:
1850: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1851: case IN:
1852: id = jj_consume_token(IN);
1853: nsExp = Expression();
1854: if (scope != Assignment.NAMESPACE) {
1855: if (true)
1856: throw new ParseException(getErrorStart(id)
1857: + "\nCannot assign to namespace here.",
1858: id.beginLine, id.beginColumn);
1859: }
1860: break;
1861: default:
1862: jj_la1[34] = jj_gen;
1863: ;
1864: }
1865: jj_consume_token(DIRECTIVE_END);
1866: block = OptionalBlock();
1867: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1868: case END_LOCAL:
1869: end = jj_consume_token(END_LOCAL);
1870: if (scope != Assignment.LOCAL) {
1871: if (true)
1872: throw new ParseException(getErrorStart(end)
1873: + "\nMismatched assignment tags.",
1874: end.beginLine, end.beginColumn);
1875: }
1876: break;
1877: case END_ASSIGN:
1878: end = jj_consume_token(END_ASSIGN);
1879: if (scope != Assignment.NAMESPACE) {
1880: if (true)
1881: throw new ParseException(getErrorStart(end)
1882: + "\nMismatched assignment tags.",
1883: end.beginLine, end.beginColumn);
1884: }
1885: break;
1886: case END_GLOBAL:
1887: end = jj_consume_token(END_GLOBAL);
1888: if (scope != Assignment.GLOBAL) {
1889: if (true)
1890: throw new ParseException(getErrorStart(end)
1891: + "\nMismatched assignment tags",
1892: end.beginLine, end.beginColumn);
1893: }
1894: break;
1895: default:
1896: jj_la1[35] = jj_gen;
1897: jj_consume_token(-1);
1898: throw new ParseException();
1899: }
1900: BlockAssignment ba = new BlockAssignment(block, varName,
1901: scope, nsExp);
1902: ba.setLocation(template, start, end);
1903: {
1904: if (true)
1905: return ba;
1906: }
1907: break;
1908: default:
1909: jj_la1[36] = jj_gen;
1910: jj_consume_token(-1);
1911: throw new ParseException();
1912: }
1913: throw new Error("Missing return statement in function");
1914: }
1915:
1916: final public Include Include() throws ParseException {
1917: Expression nameExp;
1918: Token att, start, end;
1919: Expression exp, parseExp = null, encodingExp = null;
1920: start = jj_consume_token(INCLUDE);
1921: nameExp = Expression();
1922: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1923: case SEMICOLON:
1924: jj_consume_token(SEMICOLON);
1925: break;
1926: default:
1927: jj_la1[37] = jj_gen;
1928: ;
1929: }
1930: label_10: while (true) {
1931: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1932: case ID:
1933: ;
1934: break;
1935: default:
1936: jj_la1[38] = jj_gen;
1937: break label_10;
1938: }
1939: att = jj_consume_token(ID);
1940: jj_consume_token(EQUALS);
1941: exp = Expression();
1942: String attString = att.image;
1943: if (attString.equalsIgnoreCase("parse")) {
1944: parseExp = exp;
1945: } else if (attString.equalsIgnoreCase("encoding")) {
1946: encodingExp = exp;
1947: } else {
1948: String msg = getErrorStart(att)
1949: + "\nexpecting parse= or encoding= to be specified.";
1950: {
1951: if (true)
1952: throw new ParseException(msg, att.beginLine,
1953: att.beginColumn);
1954: }
1955: }
1956: }
1957: end = LooseDirectiveEnd();
1958: Include result = new Include(template, nameExp, encodingExp,
1959: parseExp);
1960: result.setLocation(template, start, end);
1961: {
1962: if (true)
1963: return result;
1964: }
1965: throw new Error("Missing return statement in function");
1966: }
1967:
1968: final public LibraryLoad Import() throws ParseException {
1969: Token start, end, ns;
1970: Expression nameExp;
1971: start = jj_consume_token(IMPORT);
1972: nameExp = Expression();
1973: jj_consume_token(AS);
1974: ns = jj_consume_token(ID);
1975: end = LooseDirectiveEnd();
1976: LibraryLoad result = new LibraryLoad(template, nameExp,
1977: ns.image);
1978: result.setLocation(template, start, end);
1979: template.addImport(result);
1980: {
1981: if (true)
1982: return result;
1983: }
1984: throw new Error("Missing return statement in function");
1985: }
1986:
1987: final public Macro Macro() throws ParseException {
1988: Token arg, start, end;
1989: Expression nameExp;
1990: String name;
1991: ArrayList argNames = new ArrayList();
1992: HashMap args = new HashMap();
1993: ArrayList defNames = new ArrayList();
1994: Expression defValue = null;
1995: TemplateElement block;
1996: boolean isFunction = false, hasDefaults = false;
1997: boolean isCatchAll = false;
1998: String catchAll = null;
1999: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2000: case MACRO:
2001: start = jj_consume_token(MACRO);
2002: break;
2003: case FUNCTION:
2004: start = jj_consume_token(FUNCTION);
2005: isFunction = true;
2006: break;
2007: default:
2008: jj_la1[39] = jj_gen;
2009: jj_consume_token(-1);
2010: throw new ParseException();
2011: }
2012: if (inMacro || inFunction) {
2013: {
2014: if (true)
2015: throw new ParseException(getErrorStart(start)
2016: + "\nMacros cannot be nested.",
2017: start.beginLine, start.endLine);
2018: }
2019: }
2020: if (isFunction)
2021: inFunction = true;
2022: else
2023: inMacro = true;
2024: nameExp = IdentifierOrStringLiteral();
2025: name = (nameExp instanceof StringLiteral) ? ((StringLiteral) nameExp)
2026: .getAsString()
2027: : nameExp.toString();
2028: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2029: case OPEN_PAREN:
2030: jj_consume_token(OPEN_PAREN);
2031: break;
2032: default:
2033: jj_la1[40] = jj_gen;
2034: ;
2035: }
2036: label_11: while (true) {
2037: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2038: case ID:
2039: ;
2040: break;
2041: default:
2042: jj_la1[41] = jj_gen;
2043: break label_11;
2044: }
2045: arg = jj_consume_token(ID);
2046: defValue = null;
2047: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2048: case ELLIPSIS:
2049: jj_consume_token(ELLIPSIS);
2050: isCatchAll = true;
2051: break;
2052: default:
2053: jj_la1[42] = jj_gen;
2054: ;
2055: }
2056: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2057: case EQUALS:
2058: jj_consume_token(EQUALS);
2059: defValue = Expression();
2060: defNames.add(arg.image);
2061: hasDefaults = true;
2062: break;
2063: default:
2064: jj_la1[43] = jj_gen;
2065: ;
2066: }
2067: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2068: case COMMA:
2069: jj_consume_token(COMMA);
2070: break;
2071: default:
2072: jj_la1[44] = jj_gen;
2073: ;
2074: }
2075: if (catchAll != null) {
2076: {
2077: if (true)
2078: throw new ParseException(
2079: getErrorStart(arg)
2080: + "\nThere may only be one \"catch-all\" parameter in a macro declaration, "
2081: + "and it must be the last parameter.",
2082: arg.beginLine, arg.endLine);
2083: }
2084: }
2085: if (isCatchAll) {
2086: if (defValue != null) {
2087: {
2088: if (true)
2089: throw new ParseException(
2090: getErrorStart(arg)
2091: + "\n\"Catch-all\" macro parameter may not have a default value.",
2092: arg.beginLine, arg.endLine);
2093: }
2094: }
2095: catchAll = arg.image;
2096: } else {
2097: argNames.add(arg.image);
2098: if (hasDefaults && defValue == null) {
2099: {
2100: if (true)
2101: throw new ParseException(
2102: getErrorStart(arg)
2103: + "\nIn a macro declaration, parameters without a default value "
2104: + "must all occur before the parameters with default values.",
2105: arg.beginLine, arg.endLine);
2106: }
2107: }
2108: args.put(arg.image, defValue);
2109: }
2110: }
2111: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2112: case CLOSE_PAREN:
2113: jj_consume_token(CLOSE_PAREN);
2114: break;
2115: default:
2116: jj_la1[45] = jj_gen;
2117: ;
2118: }
2119: jj_consume_token(DIRECTIVE_END);
2120: block = OptionalBlock();
2121: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2122: case END_MACRO:
2123: end = jj_consume_token(END_MACRO);
2124: if (isFunction) {
2125: if (true)
2126: throw new ParseException(getErrorStart(start)
2127: + "\nExpected function end tag here.",
2128: start.beginLine, start.endLine);
2129: }
2130: break;
2131: case END_FUNCTION:
2132: end = jj_consume_token(END_FUNCTION);
2133: if (!isFunction) {
2134: if (true)
2135: throw new ParseException(getErrorStart(start)
2136: + "\nExpected macro end tag here.",
2137: start.beginLine, start.endLine);
2138: }
2139: break;
2140: default:
2141: jj_la1[46] = jj_gen;
2142: jj_consume_token(-1);
2143: throw new ParseException();
2144: }
2145: inMacro = inFunction = false;
2146: Macro result = new Macro(name, argNames, args, block);
2147: result.setCatchAll(catchAll);
2148: result.isFunction = isFunction;
2149: result.setLocation(template, start, end);
2150: template.addMacro(result);
2151: {
2152: if (true)
2153: return result;
2154: }
2155: throw new Error("Missing return statement in function");
2156: }
2157:
2158: final public CompressedBlock Compress() throws ParseException {
2159: TemplateElement block;
2160: Token start, end;
2161: start = jj_consume_token(COMPRESS);
2162: block = OptionalBlock();
2163: end = jj_consume_token(END_COMPRESS);
2164: CompressedBlock cb = new CompressedBlock(block);
2165: cb.setLocation(template, start, end);
2166: {
2167: if (true)
2168: return cb;
2169: }
2170: throw new Error("Missing return statement in function");
2171: }
2172:
2173: final public TemplateElement UnifiedMacroTransform()
2174: throws ParseException {
2175: Token start = null, end, t;
2176: HashMap namedArgs = null;
2177: ArrayList positionalArgs = null, bodyParameters = null;
2178: String directiveName = null;
2179: TemplateElement nestedBlock = null;
2180: Expression exp;
2181: start = jj_consume_token(UNIFIED_CALL);
2182: exp = Expression();
2183: if (exp instanceof Identifier
2184: || (exp instanceof Dot && ((Dot) exp)
2185: .onlyHasIdentifiers())) {
2186: directiveName = exp.getCanonicalForm();
2187: }
2188: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2189: case TERMINATING_WHITESPACE:
2190: jj_consume_token(TERMINATING_WHITESPACE);
2191: break;
2192: default:
2193: jj_la1[47] = jj_gen;
2194: ;
2195: }
2196: if (jj_2_12(2147483647)) {
2197: namedArgs = NamedArgs();
2198: } else {
2199: positionalArgs = PositionalArgs();
2200: }
2201: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2202: case SEMICOLON:
2203: jj_consume_token(SEMICOLON);
2204: bodyParameters = new ArrayList();
2205: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2206: case ID:
2207: t = jj_consume_token(ID);
2208: bodyParameters.add(t.image);
2209: label_12: while (true) {
2210: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2211: case COMMA:
2212: ;
2213: break;
2214: default:
2215: jj_la1[48] = jj_gen;
2216: break label_12;
2217: }
2218: jj_consume_token(COMMA);
2219: t = jj_consume_token(ID);
2220: bodyParameters.add(t.image);
2221: }
2222: break;
2223: default:
2224: jj_la1[49] = jj_gen;
2225: ;
2226: }
2227: break;
2228: default:
2229: jj_la1[50] = jj_gen;
2230: ;
2231: }
2232: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2233: case EMPTY_DIRECTIVE_END:
2234: end = jj_consume_token(EMPTY_DIRECTIVE_END);
2235: break;
2236: case DIRECTIVE_END:
2237: jj_consume_token(DIRECTIVE_END);
2238: nestedBlock = OptionalBlock();
2239: end = jj_consume_token(UNIFIED_CALL_END);
2240: String s = end.image.substring(3);
2241: s = s.substring(0, s.length() - 1).trim();
2242: if (s.length() > 0 && !s.equals(directiveName)) {
2243: String msg = getErrorStart(end);
2244: if (directiveName == null) {
2245: {
2246: if (true)
2247: throw new ParseException(msg
2248: + "\nExpecting </@>",
2249: end.beginLine, end.beginColumn);
2250: }
2251: } else {
2252: {
2253: if (true)
2254: throw new ParseException(msg
2255: + "\nExpecting </@> or </@"
2256: + directiveName + ">",
2257: end.beginLine, end.beginColumn);
2258: }
2259: }
2260: }
2261: break;
2262: default:
2263: jj_la1[51] = jj_gen;
2264: jj_consume_token(-1);
2265: throw new ParseException();
2266: }
2267: TemplateElement result = (positionalArgs != null) ? new UnifiedCall(
2268: exp, positionalArgs, nestedBlock, bodyParameters)
2269: : new UnifiedCall(exp, namedArgs, nestedBlock,
2270: bodyParameters);
2271: result.setLocation(template, start, end);
2272: {
2273: if (true)
2274: return result;
2275: }
2276: throw new Error("Missing return statement in function");
2277: }
2278:
2279: final public TemplateElement Call() throws ParseException {
2280: Token start, end, id;
2281: HashMap namedArgs = null;
2282: ArrayList positionalArgs = null;
2283: String macroName = null;
2284: start = jj_consume_token(CALL);
2285: id = jj_consume_token(ID);
2286: macroName = id.image;
2287: if (jj_2_14(2147483647)) {
2288: namedArgs = NamedArgs();
2289: } else {
2290: if (jj_2_13(2147483647)) {
2291: jj_consume_token(OPEN_PAREN);
2292: } else {
2293: ;
2294: }
2295: positionalArgs = PositionalArgs();
2296: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2297: case CLOSE_PAREN:
2298: jj_consume_token(CLOSE_PAREN);
2299: break;
2300: default:
2301: jj_la1[52] = jj_gen;
2302: ;
2303: }
2304: }
2305: end = LooseDirectiveEnd();
2306: UnifiedCall result = null;
2307: if (positionalArgs != null) {
2308: result = new UnifiedCall(new Identifier(macroName),
2309: positionalArgs, null, null);
2310: } else {
2311: result = new UnifiedCall(new Identifier(macroName),
2312: namedArgs, null, null);
2313: }
2314: result.legacySyntax = true;
2315: result.setLocation(template, start, end);
2316: {
2317: if (true)
2318: return result;
2319: }
2320: throw new Error("Missing return statement in function");
2321: }
2322:
2323: final public HashMap NamedArgs() throws ParseException {
2324: HashMap result = new HashMap();
2325: Token t;
2326: Expression exp;
2327: label_13: while (true) {
2328: t = jj_consume_token(ID);
2329: jj_consume_token(EQUALS);
2330: exp = Expression();
2331: result.put(t.image, exp);
2332: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2333: case ID:
2334: ;
2335: break;
2336: default:
2337: jj_la1[53] = jj_gen;
2338: break label_13;
2339: }
2340: }
2341: {
2342: if (true)
2343: return result;
2344: }
2345: throw new Error("Missing return statement in function");
2346: }
2347:
2348: final public ArrayList PositionalArgs() throws ParseException {
2349: ArrayList result = new ArrayList();
2350: Expression arg;
2351: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2352: case STRING_LITERAL:
2353: case RAW_STRING:
2354: case FALSE:
2355: case TRUE:
2356: case INTEGER:
2357: case DECIMAL:
2358: case DOT:
2359: case PLUS:
2360: case MINUS:
2361: case EXCLAM:
2362: case OPEN_BRACKET:
2363: case OPEN_PAREN:
2364: case OPEN_BRACE:
2365: case ID:
2366: arg = Expression();
2367: result.add(arg);
2368: label_14: while (true) {
2369: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2370: case STRING_LITERAL:
2371: case RAW_STRING:
2372: case FALSE:
2373: case TRUE:
2374: case INTEGER:
2375: case DECIMAL:
2376: case DOT:
2377: case PLUS:
2378: case MINUS:
2379: case EXCLAM:
2380: case COMMA:
2381: case OPEN_BRACKET:
2382: case OPEN_PAREN:
2383: case OPEN_BRACE:
2384: case ID:
2385: ;
2386: break;
2387: default:
2388: jj_la1[54] = jj_gen;
2389: break label_14;
2390: }
2391: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2392: case COMMA:
2393: jj_consume_token(COMMA);
2394: break;
2395: default:
2396: jj_la1[55] = jj_gen;
2397: ;
2398: }
2399: arg = Expression();
2400: result.add(arg);
2401: }
2402: break;
2403: default:
2404: jj_la1[56] = jj_gen;
2405: ;
2406: }
2407: {
2408: if (true)
2409: return result;
2410: }
2411: throw new Error("Missing return statement in function");
2412: }
2413:
2414: final public Comment Comment() throws ParseException {
2415: Token start, end;
2416: StringBuffer buf = new StringBuffer();
2417: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2418: case COMMENT:
2419: start = jj_consume_token(COMMENT);
2420: break;
2421: case TERSE_COMMENT:
2422: start = jj_consume_token(TERSE_COMMENT);
2423: break;
2424: default:
2425: jj_la1[57] = jj_gen;
2426: jj_consume_token(-1);
2427: throw new ParseException();
2428: }
2429: end = UnparsedContent(buf);
2430: Comment result = new Comment(buf.toString());
2431: result.setLocation(template, start, end);
2432: {
2433: if (true)
2434: return result;
2435: }
2436: throw new Error("Missing return statement in function");
2437: }
2438:
2439: final public TextBlock NoParse() throws ParseException {
2440: Token start, end;
2441: StringBuffer buf = new StringBuffer();
2442: start = jj_consume_token(NOPARSE);
2443: end = UnparsedContent(buf);
2444: TextBlock result = new TextBlock(buf.toString(), true);
2445: result.setLocation(template, start, end);
2446: {
2447: if (true)
2448: return result;
2449: }
2450: throw new Error("Missing return statement in function");
2451: }
2452:
2453: final public TransformBlock Transform() throws ParseException {
2454: Token start, end, argName;
2455: Expression exp, argExp;
2456: TemplateElement content = null;
2457: HashMap args = null;
2458: start = jj_consume_token(TRANSFORM);
2459: exp = Expression();
2460: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2461: case SEMICOLON:
2462: jj_consume_token(SEMICOLON);
2463: break;
2464: default:
2465: jj_la1[58] = jj_gen;
2466: ;
2467: }
2468: label_15: while (true) {
2469: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2470: case ID:
2471: ;
2472: break;
2473: default:
2474: jj_la1[59] = jj_gen;
2475: break label_15;
2476: }
2477: argName = jj_consume_token(ID);
2478: jj_consume_token(EQUALS);
2479: argExp = Expression();
2480: if (args == null)
2481: args = new HashMap();
2482: args.put(argName.image, argExp);
2483: }
2484: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2485: case EMPTY_DIRECTIVE_END:
2486: end = jj_consume_token(EMPTY_DIRECTIVE_END);
2487: break;
2488: case DIRECTIVE_END:
2489: jj_consume_token(DIRECTIVE_END);
2490: content = OptionalBlock();
2491: end = jj_consume_token(END_TRANSFORM);
2492: break;
2493: default:
2494: jj_la1[60] = jj_gen;
2495: jj_consume_token(-1);
2496: throw new ParseException();
2497: }
2498: TransformBlock result = new TransformBlock(exp, args, content);
2499: result.setLocation(template, start, end);
2500: {
2501: if (true)
2502: return result;
2503: }
2504: throw new Error("Missing return statement in function");
2505: }
2506:
2507: final public SwitchBlock Switch() throws ParseException {
2508: SwitchBlock switchBlock;
2509: Case caseIns;
2510: Expression switchExp;
2511: Token start, end;
2512: boolean defaultFound = false;
2513: start = jj_consume_token(SWITCH);
2514: switchExp = Expression();
2515: jj_consume_token(DIRECTIVE_END);
2516: ++switchNesting;
2517: switchBlock = new SwitchBlock(switchExp);
2518: label_16: while (true) {
2519: if (jj_2_15(2)) {
2520: ;
2521: } else {
2522: break label_16;
2523: }
2524: caseIns = Case();
2525: if (caseIns.isDefault) {
2526: if (defaultFound) {
2527: String msg = getErrorStart(start)
2528: + "\nYou can only have one default case in a switch statement";
2529: {
2530: if (true)
2531: throw new ParseException(msg,
2532: start.beginLine, start.beginColumn);
2533: }
2534: }
2535: defaultFound = true;
2536: }
2537: switchBlock.addCase(caseIns);
2538: }
2539: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2540: case WHITESPACE:
2541: jj_consume_token(WHITESPACE);
2542: break;
2543: default:
2544: jj_la1[61] = jj_gen;
2545: ;
2546: }
2547: end = jj_consume_token(END_SWITCH);
2548: --switchNesting;
2549: switchBlock.setLocation(template, start, end);
2550: {
2551: if (true)
2552: return switchBlock;
2553: }
2554: throw new Error("Missing return statement in function");
2555: }
2556:
2557: final public Case Case() throws ParseException {
2558: Expression exp = null;
2559: TemplateElement block;
2560: boolean isDefault = false;
2561: Token start;
2562: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2563: case WHITESPACE:
2564: jj_consume_token(WHITESPACE);
2565: break;
2566: default:
2567: jj_la1[62] = jj_gen;
2568: ;
2569: }
2570: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2571: case CASE:
2572: start = jj_consume_token(CASE);
2573: exp = Expression();
2574: jj_consume_token(DIRECTIVE_END);
2575: break;
2576: case DEFAUL:
2577: start = jj_consume_token(DEFAUL);
2578: isDefault = true;
2579: break;
2580: default:
2581: jj_la1[63] = jj_gen;
2582: jj_consume_token(-1);
2583: throw new ParseException();
2584: }
2585: block = OptionalBlock();
2586: Case result = new Case(exp, block, isDefault);
2587: result.setLocation(template, start, block);
2588: {
2589: if (true)
2590: return result;
2591: }
2592: throw new Error("Missing return statement in function");
2593: }
2594:
2595: final public EscapeBlock Escape() throws ParseException {
2596: Token variable, start, end;
2597: Expression escapeExpr;
2598: TemplateElement content;
2599: start = jj_consume_token(ESCAPE);
2600: variable = jj_consume_token(ID);
2601: jj_consume_token(AS);
2602: escapeExpr = Expression();
2603: jj_consume_token(DIRECTIVE_END);
2604: EscapeBlock result = new EscapeBlock(variable.image,
2605: escapeExpr, escapedExpression(escapeExpr));
2606: escapes.addFirst(result);
2607: content = OptionalBlock();
2608: result.setContent(content);
2609: escapes.removeFirst();
2610: end = jj_consume_token(END_ESCAPE);
2611: result.setLocation(template, start, end);
2612: {
2613: if (true)
2614: return result;
2615: }
2616: throw new Error("Missing return statement in function");
2617: }
2618:
2619: final public NoEscapeBlock NoEscape() throws ParseException {
2620: Token start, end;
2621: TemplateElement content;
2622: start = jj_consume_token(NOESCAPE);
2623: if (escapes.isEmpty()) {
2624: String msg = getErrorStart(start)
2625: + "\nnoescape with no matching escape encountered.";
2626: {
2627: if (true)
2628: throw new ParseException(msg, start.beginLine,
2629: start.beginColumn);
2630: }
2631: }
2632: Object escape = escapes.removeFirst();
2633: content = OptionalBlock();
2634: end = jj_consume_token(END_NOESCAPE);
2635: escapes.addFirst(escape);
2636: NoEscapeBlock result = new NoEscapeBlock(content);
2637: result.setLocation(template, start, end);
2638: {
2639: if (true)
2640: return result;
2641: }
2642: throw new Error("Missing return statement in function");
2643: }
2644:
2645: /**
2646: * Production to terminate potentially empty elements. Either a ">" or "/>"
2647: */
2648: final public Token LooseDirectiveEnd() throws ParseException {
2649: Token t;
2650: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2651: case DIRECTIVE_END:
2652: t = jj_consume_token(DIRECTIVE_END);
2653: break;
2654: case EMPTY_DIRECTIVE_END:
2655: t = jj_consume_token(EMPTY_DIRECTIVE_END);
2656: break;
2657: default:
2658: jj_la1[64] = jj_gen;
2659: jj_consume_token(-1);
2660: throw new ParseException();
2661: }
2662: {
2663: if (true)
2664: return t;
2665: }
2666: throw new Error("Missing return statement in function");
2667: }
2668:
2669: final public PropertySetting Setting() throws ParseException {
2670: Token start, end, key;
2671: Expression value;
2672: start = jj_consume_token(SETTING);
2673: key = jj_consume_token(ID);
2674: jj_consume_token(EQUALS);
2675: value = Expression();
2676: end = LooseDirectiveEnd();
2677: PropertySetting result = new PropertySetting(key.image, value);
2678: result.setLocation(template, start, end);
2679: {
2680: if (true)
2681: return result;
2682: }
2683: throw new Error("Missing return statement in function");
2684: }
2685:
2686: /**
2687: * A production for FreeMarker directives.
2688: */
2689: final public TemplateElement FreemarkerDirective()
2690: throws ParseException {
2691: TemplateElement tp;
2692: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2693: case IF:
2694: tp = If();
2695: break;
2696: case LIST:
2697: tp = List();
2698: break;
2699: case FOREACH:
2700: tp = ForEach();
2701: break;
2702: case ASSIGN:
2703: case GLOBALASSIGN:
2704: case LOCALASSIGN:
2705: tp = Assign();
2706: break;
2707: case INCLUDE:
2708: tp = Include();
2709: break;
2710: case IMPORT:
2711: tp = Import();
2712: break;
2713: case FUNCTION:
2714: case MACRO:
2715: tp = Macro();
2716: break;
2717: case COMPRESS:
2718: tp = Compress();
2719: break;
2720: case UNIFIED_CALL:
2721: tp = UnifiedMacroTransform();
2722: break;
2723: case CALL:
2724: tp = Call();
2725: break;
2726: case COMMENT:
2727: case TERSE_COMMENT:
2728: tp = Comment();
2729: break;
2730: case NOPARSE:
2731: tp = NoParse();
2732: break;
2733: case TRANSFORM:
2734: tp = Transform();
2735: break;
2736: case SWITCH:
2737: tp = Switch();
2738: break;
2739: case SETTING:
2740: tp = Setting();
2741: break;
2742: case BREAK:
2743: tp = Break();
2744: break;
2745: case RETURN:
2746: case SIMPLE_RETURN:
2747: tp = Return();
2748: break;
2749: case STOP:
2750: case HALT:
2751: tp = Stop();
2752: break;
2753: case FLUSH:
2754: tp = Flush();
2755: break;
2756: case TRIM:
2757: case LTRIM:
2758: case RTRIM:
2759: case NOTRIM:
2760: tp = Trim();
2761: break;
2762: case SIMPLE_NESTED:
2763: case NESTED:
2764: tp = Nested();
2765: break;
2766: case ESCAPE:
2767: tp = Escape();
2768: break;
2769: case NOESCAPE:
2770: tp = NoEscape();
2771: break;
2772: case VISIT:
2773: tp = Visit();
2774: break;
2775: case SIMPLE_RECURSE:
2776: case RECURSE:
2777: tp = Recurse();
2778: break;
2779: case FALLBACK:
2780: tp = FallBack();
2781: break;
2782: case ATTEMPT:
2783: tp = Attempt();
2784: break;
2785: default:
2786: jj_la1[65] = jj_gen;
2787: jj_consume_token(-1);
2788: throw new ParseException();
2789: }
2790: {
2791: if (true)
2792: return tp;
2793: }
2794: throw new Error("Missing return statement in function");
2795: }
2796:
2797: /**
2798: * Production for a block of raw text
2799: * i.e. text that contains no
2800: * FreeMarker directives.
2801: */
2802: final public TextBlock PCData() throws ParseException {
2803: StringBuffer buf = new StringBuffer();
2804: Token t, start = null;
2805: label_17: while (true) {
2806: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2807: case WHITESPACE:
2808: t = jj_consume_token(WHITESPACE);
2809: break;
2810: case PRINTABLE_CHARS:
2811: t = jj_consume_token(PRINTABLE_CHARS);
2812: break;
2813: case FALSE_ALERT:
2814: t = jj_consume_token(FALSE_ALERT);
2815: break;
2816: default:
2817: jj_la1[66] = jj_gen;
2818: jj_consume_token(-1);
2819: throw new ParseException();
2820: }
2821: buf.append(t.image);
2822: if (start == null)
2823: start = t;
2824: if (jj_2_16(2147483647)) {
2825: ;
2826: } else {
2827: break label_17;
2828: }
2829: }
2830: if (stripText && contentNesting == 1) {
2831: if (true)
2832: return TextBlock.EMPTY_BLOCK;
2833: }
2834:
2835: TextBlock result = new TextBlock(buf.toString(), false);
2836: result.setLocation(template, start, t);
2837: {
2838: if (true)
2839: return result;
2840: }
2841: throw new Error("Missing return statement in function");
2842: }
2843:
2844: /**
2845: * Production for dealing with unparsed content,
2846: * i.e. what is inside a comment or noparse tag.
2847: * It returns the ending token. The content
2848: * of the tag is put in buf.
2849: */
2850: final public Token UnparsedContent(StringBuffer buf)
2851: throws ParseException {
2852: Token t;
2853: label_18: while (true) {
2854: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2855: case KEEP_GOING:
2856: t = jj_consume_token(KEEP_GOING);
2857: break;
2858: case MAYBE_END:
2859: t = jj_consume_token(MAYBE_END);
2860: break;
2861: case TERSE_COMMENT_END:
2862: t = jj_consume_token(TERSE_COMMENT_END);
2863: break;
2864: case LONE_LESS_THAN_OR_DASH:
2865: t = jj_consume_token(LONE_LESS_THAN_OR_DASH);
2866: break;
2867: default:
2868: jj_la1[67] = jj_gen;
2869: jj_consume_token(-1);
2870: throw new ParseException();
2871: }
2872: buf.append(t.image);
2873: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2874: case TERSE_COMMENT_END:
2875: case MAYBE_END:
2876: case KEEP_GOING:
2877: case LONE_LESS_THAN_OR_DASH:
2878: ;
2879: break;
2880: default:
2881: jj_la1[68] = jj_gen;
2882: break label_18;
2883: }
2884: }
2885: buf.setLength(buf.length() - t.image.length());
2886: {
2887: if (true)
2888: return t;
2889: }
2890: throw new Error("Missing return statement in function");
2891: }
2892:
2893: final public TemplateElement Content() throws ParseException {
2894: MixedContent nodes = new MixedContent();
2895: TemplateElement elem, begin = null;
2896: contentNesting++;
2897: label_19: while (true) {
2898: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2899: case WHITESPACE:
2900: case PRINTABLE_CHARS:
2901: case FALSE_ALERT:
2902: elem = PCData();
2903: break;
2904: case OUTPUT_ESCAPE:
2905: elem = StringOutput();
2906: break;
2907: case NUMERICAL_ESCAPE:
2908: elem = NumericalOutput();
2909: break;
2910: case ATTEMPT:
2911: case IF:
2912: case LIST:
2913: case FOREACH:
2914: case SWITCH:
2915: case ASSIGN:
2916: case GLOBALASSIGN:
2917: case LOCALASSIGN:
2918: case INCLUDE:
2919: case IMPORT:
2920: case FUNCTION:
2921: case MACRO:
2922: case TRANSFORM:
2923: case VISIT:
2924: case STOP:
2925: case RETURN:
2926: case CALL:
2927: case SETTING:
2928: case COMPRESS:
2929: case COMMENT:
2930: case TERSE_COMMENT:
2931: case NOPARSE:
2932: case BREAK:
2933: case SIMPLE_RETURN:
2934: case HALT:
2935: case FLUSH:
2936: case TRIM:
2937: case LTRIM:
2938: case RTRIM:
2939: case NOTRIM:
2940: case SIMPLE_NESTED:
2941: case NESTED:
2942: case SIMPLE_RECURSE:
2943: case RECURSE:
2944: case FALLBACK:
2945: case ESCAPE:
2946: case NOESCAPE:
2947: case UNIFIED_CALL:
2948: elem = FreemarkerDirective();
2949: break;
2950: default:
2951: jj_la1[69] = jj_gen;
2952: jj_consume_token(-1);
2953: throw new ParseException();
2954: }
2955: if (begin == null) {
2956: begin = elem;
2957: }
2958: nodes.addElement(elem);
2959: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2960: case ATTEMPT:
2961: case IF:
2962: case LIST:
2963: case FOREACH:
2964: case SWITCH:
2965: case ASSIGN:
2966: case GLOBALASSIGN:
2967: case LOCALASSIGN:
2968: case INCLUDE:
2969: case IMPORT:
2970: case FUNCTION:
2971: case MACRO:
2972: case TRANSFORM:
2973: case VISIT:
2974: case STOP:
2975: case RETURN:
2976: case CALL:
2977: case SETTING:
2978: case COMPRESS:
2979: case COMMENT:
2980: case TERSE_COMMENT:
2981: case NOPARSE:
2982: case BREAK:
2983: case SIMPLE_RETURN:
2984: case HALT:
2985: case FLUSH:
2986: case TRIM:
2987: case LTRIM:
2988: case RTRIM:
2989: case NOTRIM:
2990: case SIMPLE_NESTED:
2991: case NESTED:
2992: case SIMPLE_RECURSE:
2993: case RECURSE:
2994: case FALLBACK:
2995: case ESCAPE:
2996: case NOESCAPE:
2997: case UNIFIED_CALL:
2998: case WHITESPACE:
2999: case PRINTABLE_CHARS:
3000: case FALSE_ALERT:
3001: case OUTPUT_ESCAPE:
3002: case NUMERICAL_ESCAPE:
3003: ;
3004: break;
3005: default:
3006: jj_la1[70] = jj_gen;
3007: break label_19;
3008: }
3009: }
3010: contentNesting--;
3011: nodes.setLocation(template, begin, elem);
3012: {
3013: if (true)
3014: return nodes;
3015: }
3016: throw new Error("Missing return statement in function");
3017: }
3018:
3019: /**
3020: * A production freemarker text that may contain
3021: * ${...} and #{...} but no directives.
3022: */
3023: final public TemplateElement FreeMarkerText() throws ParseException {
3024: MixedContent nodes = new MixedContent();
3025: TemplateElement elem, begin = null;
3026: label_20: while (true) {
3027: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3028: case WHITESPACE:
3029: case PRINTABLE_CHARS:
3030: case FALSE_ALERT:
3031: elem = PCData();
3032: break;
3033: case OUTPUT_ESCAPE:
3034: elem = StringOutput();
3035: break;
3036: case NUMERICAL_ESCAPE:
3037: elem = NumericalOutput();
3038: break;
3039: default:
3040: jj_la1[71] = jj_gen;
3041: jj_consume_token(-1);
3042: throw new ParseException();
3043: }
3044: if (begin == null) {
3045: begin = elem;
3046: }
3047: nodes.addElement(elem);
3048: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3049: case WHITESPACE:
3050: case PRINTABLE_CHARS:
3051: case FALSE_ALERT:
3052: case OUTPUT_ESCAPE:
3053: case NUMERICAL_ESCAPE:
3054: ;
3055: break;
3056: default:
3057: jj_la1[72] = jj_gen;
3058: break label_20;
3059: }
3060: }
3061: nodes.setLocation(template, begin, elem);
3062: {
3063: if (true)
3064: return nodes;
3065: }
3066: throw new Error("Missing return statement in function");
3067: }
3068:
3069: /**
3070: * A production for a block of optional content.
3071: * Returns an empty Text block if there is no
3072: * content.
3073: */
3074: final public TemplateElement OptionalBlock() throws ParseException {
3075: TemplateElement tp = TextBlock.EMPTY_BLOCK;
3076: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3077: case ATTEMPT:
3078: case IF:
3079: case LIST:
3080: case FOREACH:
3081: case SWITCH:
3082: case ASSIGN:
3083: case GLOBALASSIGN:
3084: case LOCALASSIGN:
3085: case INCLUDE:
3086: case IMPORT:
3087: case FUNCTION:
3088: case MACRO:
3089: case TRANSFORM:
3090: case VISIT:
3091: case STOP:
3092: case RETURN:
3093: case CALL:
3094: case SETTING:
3095: case COMPRESS:
3096: case COMMENT:
3097: case TERSE_COMMENT:
3098: case NOPARSE:
3099: case BREAK:
3100: case SIMPLE_RETURN:
3101: case HALT:
3102: case FLUSH:
3103: case TRIM:
3104: case LTRIM:
3105: case RTRIM:
3106: case NOTRIM:
3107: case SIMPLE_NESTED:
3108: case NESTED:
3109: case SIMPLE_RECURSE:
3110: case RECURSE:
3111: case FALLBACK:
3112: case ESCAPE:
3113: case NOESCAPE:
3114: case UNIFIED_CALL:
3115: case WHITESPACE:
3116: case PRINTABLE_CHARS:
3117: case FALSE_ALERT:
3118: case OUTPUT_ESCAPE:
3119: case NUMERICAL_ESCAPE:
3120: // has no effect but to get rid of a spurious warning.
3121: tp = Content();
3122: break;
3123: default:
3124: jj_la1[73] = jj_gen;
3125: ;
3126: }
3127: {
3128: if (true)
3129: return tp;
3130: }
3131: throw new Error("Missing return statement in function");
3132: }
3133:
3134: final public void HeaderElement() throws ParseException {
3135: Token key;
3136: Expression exp = null;
3137: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3138: case WHITESPACE:
3139: jj_consume_token(WHITESPACE);
3140: break;
3141: default:
3142: jj_la1[74] = jj_gen;
3143: ;
3144: }
3145: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3146: case TRIVIAL_FTL_HEADER:
3147: jj_consume_token(TRIVIAL_FTL_HEADER);
3148: break;
3149: case FTL_HEADER:
3150: jj_consume_token(FTL_HEADER);
3151: label_21: while (true) {
3152: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3153: case ID:
3154: ;
3155: break;
3156: default:
3157: jj_la1[75] = jj_gen;
3158: break label_21;
3159: }
3160: key = jj_consume_token(ID);
3161: jj_consume_token(EQUALS);
3162: exp = Expression();
3163: String ks = key.image;
3164: TemplateModel value = null;
3165: try {
3166: value = exp.getAsTemplateModel(null);
3167: } catch (Exception e) {
3168: {
3169: if (true)
3170: throw new ParseException(
3171: "Could not evaluate expression: "
3172: + exp.getCanonicalForm()
3173: + " "
3174: + exp.getStartLocation()
3175: + "\nUnderlying cause: "
3176: + e.getMessage(), exp);
3177: }
3178: }
3179: String vs = null;
3180: if (value instanceof TemplateScalarModel) {
3181: try {
3182: vs = ((TemplateScalarModel) exp).getAsString();
3183: } catch (TemplateModelException tme) {
3184: }
3185: }
3186: if (template != null) {
3187: if (ks.equalsIgnoreCase("encoding")) {
3188: if (vs == null) {
3189: {
3190: if (true)
3191: throw new ParseException(
3192: "expecting encoding string here: "
3193: + exp
3194: .getStartLocation(),
3195: exp);
3196: }
3197: }
3198: String encoding = template.getEncoding();
3199: if (encoding != null && !encoding.equals(vs)) {
3200: {
3201: if (true)
3202: throw new Template.WrongEncodingException(
3203: vs);
3204: }
3205: }
3206: } else if (ks.equalsIgnoreCase("STRIP_WHITESPACE")) {
3207: this .stripWhitespace = getBoolean(exp);
3208: } else if (ks.equalsIgnoreCase("STRIP_TEXT")) {
3209: this .stripText = getBoolean(exp);
3210: } else if (ks.equalsIgnoreCase("STRICT_SYNTAX")) {
3211: this .token_source.strictEscapeSyntax = getBoolean(exp);
3212: } else if (ks.equalsIgnoreCase("ns_prefixes")) {
3213: if (!(value instanceof TemplateHashModelEx)) {
3214: {
3215: if (true)
3216: throw new ParseException(
3217: "Expecting a hash of prefixes to namespace URI's here. "
3218: + exp
3219: .getStartLocation(),
3220: exp);
3221: }
3222: }
3223: TemplateHashModelEx prefixMap = (TemplateHashModelEx) value;
3224: try {
3225: TemplateCollectionModel keys = prefixMap
3226: .keys();
3227: for (TemplateModelIterator it = keys
3228: .iterator(); it.hasNext();) {
3229: String prefix = ((TemplateScalarModel) it
3230: .next()).getAsString();
3231: TemplateModel valueModel = prefixMap
3232: .get(prefix);
3233: if (!(valueModel instanceof TemplateScalarModel)) {
3234: {
3235: if (true)
3236: throw new ParseException(
3237: "Non-string value in prefix to namespace hash. "
3238: + exp
3239: .getStartLocation(),
3240: exp);
3241: }
3242: }
3243: String nsURI = ((TemplateScalarModel) valueModel)
3244: .getAsString();
3245: try {
3246: template.addPrefixNSMapping(prefix,
3247: nsURI);
3248: } catch (IllegalArgumentException iae) {
3249: {
3250: if (true)
3251: throw new ParseException(
3252: iae.getMessage()
3253: + " "
3254: + exp
3255: .getStartLocation(),
3256: exp);
3257: }
3258: }
3259: }
3260: } catch (TemplateModelException tme) {
3261: }
3262: } else if (ks.equalsIgnoreCase("attributes")) {
3263: if (!(value instanceof TemplateHashModelEx)) {
3264: {
3265: if (true)
3266: throw new ParseException(
3267: "Expecting a hash of attribute names to values here. "
3268: + exp
3269: .getStartLocation(),
3270: exp);
3271: }
3272: }
3273: TemplateHashModelEx attributeMap = (TemplateHashModelEx) value;
3274: try {
3275: TemplateCollectionModel keys = attributeMap
3276: .keys();
3277: for (TemplateModelIterator it = keys
3278: .iterator(); it.hasNext();) {
3279: String attName = ((TemplateScalarModel) it
3280: .next()).getAsString();
3281: Object attValue = DeepUnwrap
3282: .unwrap(attributeMap
3283: .get(attName));
3284: template.setCustomAttribute(attName,
3285: attValue);
3286: }
3287: } catch (TemplateModelException tme) {
3288: }
3289: } else {
3290: {
3291: if (true)
3292: throw new ParseException(
3293: "Unknown FTL header parameter: "
3294: + key.image,
3295: key.beginLine, key.beginColumn);
3296: }
3297: }
3298: }
3299: }
3300: LooseDirectiveEnd();
3301: break;
3302: default:
3303: jj_la1[76] = jj_gen;
3304: jj_consume_token(-1);
3305: throw new ParseException();
3306: }
3307: }
3308:
3309: final public Map ParamList() throws ParseException {
3310: Identifier id;
3311: Expression exp;
3312: Map result = new HashMap();
3313: label_22: while (true) {
3314: id = Identifier();
3315: jj_consume_token(EQUALS);
3316: exp = Expression();
3317: result.put(id.toString(), exp);
3318: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3319: case COMMA:
3320: jj_consume_token(COMMA);
3321: break;
3322: default:
3323: jj_la1[77] = jj_gen;
3324: ;
3325: }
3326: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3327: case ID:
3328: ;
3329: break;
3330: default:
3331: jj_la1[78] = jj_gen;
3332: break label_22;
3333: }
3334: }
3335: {
3336: if (true)
3337: return result;
3338: }
3339: throw new Error("Missing return statement in function");
3340: }
3341:
3342: /**
3343: * Root production to be used when parsing
3344: * an entire file.
3345: */
3346: final public TemplateElement Root() throws ParseException {
3347: TemplateElement doc;
3348: if (jj_2_17(2147483647)) {
3349: HeaderElement();
3350: } else {
3351: ;
3352: }
3353: doc = OptionalBlock();
3354: jj_consume_token(0);
3355: doc.setParentRecursively(null);
3356: {
3357: if (true)
3358: return doc.postParseCleanup(stripWhitespace);
3359: }
3360: throw new Error("Missing return statement in function");
3361: }
3362:
3363: final private boolean jj_2_1(int xla) {
3364: jj_la = xla;
3365: jj_lastpos = jj_scanpos = token;
3366: boolean retval = !jj_3_1();
3367: jj_save(0, xla);
3368: return retval;
3369: }
3370:
3371: final private boolean jj_2_2(int xla) {
3372: jj_la = xla;
3373: jj_lastpos = jj_scanpos = token;
3374: boolean retval = !jj_3_2();
3375: jj_save(1, xla);
3376: return retval;
3377: }
3378:
3379: final private boolean jj_2_3(int xla) {
3380: jj_la = xla;
3381: jj_lastpos = jj_scanpos = token;
3382: boolean retval = !jj_3_3();
3383: jj_save(2, xla);
3384: return retval;
3385: }
3386:
3387: final private boolean jj_2_4(int xla) {
3388: jj_la = xla;
3389: jj_lastpos = jj_scanpos = token;
3390: boolean retval = !jj_3_4();
3391: jj_save(3, xla);
3392: return retval;
3393: }
3394:
3395: final private boolean jj_2_5(int xla) {
3396: jj_la = xla;
3397: jj_lastpos = jj_scanpos = token;
3398: boolean retval = !jj_3_5();
3399: jj_save(4, xla);
3400: return retval;
3401: }
3402:
3403: final private boolean jj_2_6(int xla) {
3404: jj_la = xla;
3405: jj_lastpos = jj_scanpos = token;
3406: boolean retval = !jj_3_6();
3407: jj_save(5, xla);
3408: return retval;
3409: }
3410:
3411: final private boolean jj_2_7(int xla) {
3412: jj_la = xla;
3413: jj_lastpos = jj_scanpos = token;
3414: boolean retval = !jj_3_7();
3415: jj_save(6, xla);
3416: return retval;
3417: }
3418:
3419: final private boolean jj_2_8(int xla) {
3420: jj_la = xla;
3421: jj_lastpos = jj_scanpos = token;
3422: boolean retval = !jj_3_8();
3423: jj_save(7, xla);
3424: return retval;
3425: }
3426:
3427: final private boolean jj_2_9(int xla) {
3428: jj_la = xla;
3429: jj_lastpos = jj_scanpos = token;
3430: boolean retval = !jj_3_9();
3431: jj_save(8, xla);
3432: return retval;
3433: }
3434:
3435: final private boolean jj_2_10(int xla) {
3436: jj_la = xla;
3437: jj_lastpos = jj_scanpos = token;
3438: boolean retval = !jj_3_10();
3439: jj_save(9, xla);
3440: return retval;
3441: }
3442:
3443: final private boolean jj_2_11(int xla) {
3444: jj_la = xla;
3445: jj_lastpos = jj_scanpos = token;
3446: boolean retval = !jj_3_11();
3447: jj_save(10, xla);
3448: return retval;
3449: }
3450:
3451: final private boolean jj_2_12(int xla) {
3452: jj_la = xla;
3453: jj_lastpos = jj_scanpos = token;
3454: boolean retval = !jj_3_12();
3455: jj_save(11, xla);
3456: return retval;
3457: }
3458:
3459: final private boolean jj_2_13(int xla) {
3460: jj_la = xla;
3461: jj_lastpos = jj_scanpos = token;
3462: boolean retval = !jj_3_13();
3463: jj_save(12, xla);
3464: return retval;
3465: }
3466:
3467: final private boolean jj_2_14(int xla) {
3468: jj_la = xla;
3469: jj_lastpos = jj_scanpos = token;
3470: boolean retval = !jj_3_14();
3471: jj_save(13, xla);
3472: return retval;
3473: }
3474:
3475: final private boolean jj_2_15(int xla) {
3476: jj_la = xla;
3477: jj_lastpos = jj_scanpos = token;
3478: boolean retval = !jj_3_15();
3479: jj_save(14, xla);
3480: return retval;
3481: }
3482:
3483: final private boolean jj_2_16(int xla) {
3484: jj_la = xla;
3485: jj_lastpos = jj_scanpos = token;
3486: boolean retval = !jj_3_16();
3487: jj_save(15, xla);
3488: return retval;
3489: }
3490:
3491: final private boolean jj_2_17(int xla) {
3492: jj_la = xla;
3493: jj_lastpos = jj_scanpos = token;
3494: boolean retval = !jj_3_17();
3495: jj_save(16, xla);
3496: return retval;
3497: }
3498:
3499: final private boolean jj_3R_142() {
3500: if (jj_scan_token(SETTING))
3501: return true;
3502: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3503: return false;
3504: return false;
3505: }
3506:
3507: final private boolean jj_3R_53() {
3508: if (jj_scan_token(TRIVIAL_FTL_HEADER))
3509: return true;
3510: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3511: return false;
3512: return false;
3513: }
3514:
3515: final private boolean jj_3R_208() {
3516: if (jj_scan_token(RAW_STRING))
3517: return true;
3518: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3519: return false;
3520: return false;
3521: }
3522:
3523: final private boolean jj_3R_207() {
3524: if (jj_scan_token(STRING_LITERAL))
3525: return true;
3526: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3527: return false;
3528: return false;
3529: }
3530:
3531: final private boolean jj_3R_197() {
3532: Token xsp;
3533: xsp = jj_scanpos;
3534: if (jj_3R_207()) {
3535: jj_scanpos = xsp;
3536: if (jj_3R_208())
3537: return true;
3538: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3539: return false;
3540: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3541: return false;
3542: return false;
3543: }
3544:
3545: final private boolean jj_3R_153() {
3546: if (jj_scan_token(FALLBACK))
3547: return true;
3548: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3549: return false;
3550: return false;
3551: }
3552:
3553: final private boolean jj_3_4() {
3554: Token xsp;
3555: xsp = jj_scanpos;
3556: if (jj_3R_34()) {
3557: jj_scanpos = xsp;
3558: if (jj_3R_35()) {
3559: jj_scanpos = xsp;
3560: if (jj_3R_36())
3561: return true;
3562: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3563: return false;
3564: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3565: return false;
3566: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3567: return false;
3568: return false;
3569: }
3570:
3571: final private boolean jj_3R_34() {
3572: if (jj_scan_token(NOT_EQUALS))
3573: return true;
3574: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3575: return false;
3576: return false;
3577: }
3578:
3579: final private boolean jj_3R_52() {
3580: if (jj_scan_token(WHITESPACE))
3581: return true;
3582: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3583: return false;
3584: return false;
3585: }
3586:
3587: final private boolean jj_3_17() {
3588: Token xsp;
3589: xsp = jj_scanpos;
3590: if (jj_3R_52())
3591: jj_scanpos = xsp;
3592: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3593: return false;
3594: xsp = jj_scanpos;
3595: if (jj_3R_53()) {
3596: jj_scanpos = xsp;
3597: if (jj_3R_54())
3598: return true;
3599: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3600: return false;
3601: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3602: return false;
3603: return false;
3604: }
3605:
3606: final private boolean jj_3R_73() {
3607: if (jj_scan_token(DOUBLE_EQUALS))
3608: return true;
3609: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3610: return false;
3611: return false;
3612: }
3613:
3614: final private boolean jj_3R_72() {
3615: if (jj_scan_token(EQUALS))
3616: return true;
3617: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3618: return false;
3619: return false;
3620: }
3621:
3622: final private boolean jj_3R_67() {
3623: Token xsp;
3624: xsp = jj_scanpos;
3625: if (jj_3R_71()) {
3626: jj_scanpos = xsp;
3627: if (jj_3R_72()) {
3628: jj_scanpos = xsp;
3629: if (jj_3R_73())
3630: return true;
3631: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3632: return false;
3633: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3634: return false;
3635: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3636: return false;
3637: if (jj_3R_66())
3638: return true;
3639: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3640: return false;
3641: return false;
3642: }
3643:
3644: final private boolean jj_3R_71() {
3645: if (jj_scan_token(NOT_EQUALS))
3646: return true;
3647: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3648: return false;
3649: return false;
3650: }
3651:
3652: final private boolean jj_3R_224() {
3653: if (jj_scan_token(OPEN_PAREN))
3654: return true;
3655: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3656: return false;
3657: if (jj_3R_211())
3658: return true;
3659: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3660: return false;
3661: if (jj_scan_token(CLOSE_PAREN))
3662: return true;
3663: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3664: return false;
3665: return false;
3666: }
3667:
3668: final private boolean jj_3R_63() {
3669: if (jj_3R_66())
3670: return true;
3671: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3672: return false;
3673: Token xsp;
3674: xsp = jj_scanpos;
3675: if (jj_3R_67())
3676: jj_scanpos = xsp;
3677: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3678: return false;
3679: return false;
3680: }
3681:
3682: final private boolean jj_3R_179() {
3683: if (jj_scan_token(RECURSE))
3684: return true;
3685: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3686: return false;
3687: return false;
3688: }
3689:
3690: final private boolean jj_3R_33() {
3691: if (jj_scan_token(PERCENT))
3692: return true;
3693: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3694: return false;
3695: return false;
3696: }
3697:
3698: final private boolean jj_3R_178() {
3699: if (jj_scan_token(SIMPLE_RECURSE))
3700: return true;
3701: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3702: return false;
3703: return false;
3704: }
3705:
3706: final private boolean jj_3R_152() {
3707: Token xsp;
3708: xsp = jj_scanpos;
3709: if (jj_3R_178()) {
3710: jj_scanpos = xsp;
3711: if (jj_3R_179())
3712: return true;
3713: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3714: return false;
3715: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3716: return false;
3717: return false;
3718: }
3719:
3720: final private boolean jj_3R_32() {
3721: if (jj_scan_token(DIVIDE))
3722: return true;
3723: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3724: return false;
3725: return false;
3726: }
3727:
3728: final private boolean jj_3R_150() {
3729: if (jj_scan_token(NOESCAPE))
3730: return true;
3731: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3732: return false;
3733: return false;
3734: }
3735:
3736: final private boolean jj_3R_223() {
3737: if (jj_scan_token(OPEN_BRACKET))
3738: return true;
3739: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3740: return false;
3741: if (jj_3R_44())
3742: return true;
3743: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3744: return false;
3745: if (jj_scan_token(CLOSE_BRACKET))
3746: return true;
3747: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3748: return false;
3749: return false;
3750: }
3751:
3752: final private boolean jj_3R_160() {
3753: if (jj_scan_token(PERCENT))
3754: return true;
3755: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3756: return false;
3757: return false;
3758: }
3759:
3760: final private boolean jj_3_3() {
3761: Token xsp;
3762: xsp = jj_scanpos;
3763: if (jj_3R_31()) {
3764: jj_scanpos = xsp;
3765: if (jj_3R_32()) {
3766: jj_scanpos = xsp;
3767: if (jj_3R_33())
3768: return true;
3769: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3770: return false;
3771: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3772: return false;
3773: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3774: return false;
3775: return false;
3776: }
3777:
3778: final private boolean jj_3R_31() {
3779: if (jj_scan_token(TIMES))
3780: return true;
3781: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3782: return false;
3783: return false;
3784: }
3785:
3786: final private boolean jj_3R_165() {
3787: if (jj_scan_token(FUNCTION))
3788: return true;
3789: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3790: return false;
3791: return false;
3792: }
3793:
3794: final private boolean jj_3R_159() {
3795: if (jj_scan_token(DIVIDE))
3796: return true;
3797: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3798: return false;
3799: return false;
3800: }
3801:
3802: final private boolean jj_3R_164() {
3803: if (jj_scan_token(MACRO))
3804: return true;
3805: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3806: return false;
3807: return false;
3808: }
3809:
3810: final private boolean jj_3R_158() {
3811: if (jj_scan_token(TIMES))
3812: return true;
3813: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3814: return false;
3815: return false;
3816: }
3817:
3818: final private boolean jj_3R_134() {
3819: Token xsp;
3820: xsp = jj_scanpos;
3821: if (jj_3R_164()) {
3822: jj_scanpos = xsp;
3823: if (jj_3R_165())
3824: return true;
3825: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3826: return false;
3827: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3828: return false;
3829: return false;
3830: }
3831:
3832: final private boolean jj_3R_151() {
3833: if (jj_scan_token(VISIT))
3834: return true;
3835: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3836: return false;
3837: return false;
3838: }
3839:
3840: final private boolean jj_3R_122() {
3841: Token xsp;
3842: xsp = jj_scanpos;
3843: if (jj_3R_158()) {
3844: jj_scanpos = xsp;
3845: if (jj_3R_159()) {
3846: jj_scanpos = xsp;
3847: if (jj_3R_160())
3848: return true;
3849: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3850: return false;
3851: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3852: return false;
3853: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3854: return false;
3855: if (jj_3R_121())
3856: return true;
3857: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3858: return false;
3859: return false;
3860: }
3861:
3862: final private boolean jj_3R_233() {
3863: if (jj_scan_token(DOUBLE_STAR))
3864: return true;
3865: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3866: return false;
3867: return false;
3868: }
3869:
3870: final private boolean jj_3R_90() {
3871: if (jj_3R_121())
3872: return true;
3873: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3874: return false;
3875: Token xsp;
3876: while (true) {
3877: xsp = jj_scanpos;
3878: if (jj_3R_122()) {
3879: jj_scanpos = xsp;
3880: break;
3881: }
3882: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3883: return false;
3884: }
3885: return false;
3886: }
3887:
3888: final private boolean jj_3R_245() {
3889: if (jj_scan_token(USING))
3890: return true;
3891: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3892: return false;
3893: return false;
3894: }
3895:
3896: final private boolean jj_3R_244() {
3897: if (jj_scan_token(AS))
3898: return true;
3899: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3900: return false;
3901: return false;
3902: }
3903:
3904: final private boolean jj_3R_243() {
3905: if (jj_scan_token(IN))
3906: return true;
3907: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3908: return false;
3909: return false;
3910: }
3911:
3912: final private boolean jj_3R_242() {
3913: if (jj_scan_token(TRUE))
3914: return true;
3915: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3916: return false;
3917: return false;
3918: }
3919:
3920: final private boolean jj_3R_241() {
3921: if (jj_scan_token(FALSE))
3922: return true;
3923: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3924: return false;
3925: return false;
3926: }
3927:
3928: final private boolean jj_3R_149() {
3929: if (jj_scan_token(ESCAPE))
3930: return true;
3931: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3932: return false;
3933: return false;
3934: }
3935:
3936: final private boolean jj_3R_240() {
3937: if (jj_scan_token(ESCAPED_GTE))
3938: return true;
3939: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3940: return false;
3941: return false;
3942: }
3943:
3944: final private boolean jj_3R_239() {
3945: if (jj_scan_token(ESCAPED_GT))
3946: return true;
3947: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3948: return false;
3949: return false;
3950: }
3951:
3952: final private boolean jj_3R_232() {
3953: if (jj_scan_token(TIMES))
3954: return true;
3955: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3956: return false;
3957: return false;
3958: }
3959:
3960: final private boolean jj_3R_238() {
3961: if (jj_scan_token(LESS_THAN_EQUALS))
3962: return true;
3963: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3964: return false;
3965: return false;
3966: }
3967:
3968: final private boolean jj_3R_237() {
3969: if (jj_scan_token(LESS_THAN))
3970: return true;
3971: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3972: return false;
3973: return false;
3974: }
3975:
3976: final private boolean jj_3R_234() {
3977: Token xsp;
3978: xsp = jj_scanpos;
3979: if (jj_3R_237()) {
3980: jj_scanpos = xsp;
3981: if (jj_3R_238()) {
3982: jj_scanpos = xsp;
3983: if (jj_3R_239()) {
3984: jj_scanpos = xsp;
3985: if (jj_3R_240()) {
3986: jj_scanpos = xsp;
3987: if (jj_3R_241()) {
3988: jj_scanpos = xsp;
3989: if (jj_3R_242()) {
3990: jj_scanpos = xsp;
3991: if (jj_3R_243()) {
3992: jj_scanpos = xsp;
3993: if (jj_3R_244()) {
3994: jj_scanpos = xsp;
3995: if (jj_3R_245())
3996: return true;
3997: if (jj_la == 0
3998: && jj_scanpos == jj_lastpos)
3999: return false;
4000: } else if (jj_la == 0
4001: && jj_scanpos == jj_lastpos)
4002: return false;
4003: } else if (jj_la == 0
4004: && jj_scanpos == jj_lastpos)
4005: return false;
4006: } else if (jj_la == 0
4007: && jj_scanpos == jj_lastpos)
4008: return false;
4009: } else if (jj_la == 0
4010: && jj_scanpos == jj_lastpos)
4011: return false;
4012: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4013: return false;
4014: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4015: return false;
4016: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4017: return false;
4018: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4019: return false;
4020: return false;
4021: }
4022:
4023: final private boolean jj_3R_130() {
4024: if (jj_scan_token(FOREACH))
4025: return true;
4026: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4027: return false;
4028: return false;
4029: }
4030:
4031: final private boolean jj_3R_231() {
4032: if (jj_scan_token(ID))
4033: return true;
4034: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4035: return false;
4036: return false;
4037: }
4038:
4039: final private boolean jj_3R_30() {
4040: if (jj_scan_token(MINUS))
4041: return true;
4042: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4043: return false;
4044: return false;
4045: }
4046:
4047: final private boolean jj_3R_133() {
4048: if (jj_scan_token(IMPORT))
4049: return true;
4050: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4051: return false;
4052: return false;
4053: }
4054:
4055: final private boolean jj_3R_58() {
4056: if (jj_scan_token(DEFAUL))
4057: return true;
4058: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4059: return false;
4060: return false;
4061: }
4062:
4063: final private boolean jj_3R_222() {
4064: if (jj_scan_token(DOT))
4065: return true;
4066: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4067: return false;
4068: Token xsp;
4069: xsp = jj_scanpos;
4070: if (jj_3R_231()) {
4071: jj_scanpos = xsp;
4072: if (jj_3R_232()) {
4073: jj_scanpos = xsp;
4074: if (jj_3R_233()) {
4075: jj_scanpos = xsp;
4076: if (jj_3R_234())
4077: return true;
4078: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4079: return false;
4080: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4081: return false;
4082: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4083: return false;
4084: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4085: return false;
4086: return false;
4087: }
4088:
4089: final private boolean jj_3R_57() {
4090: if (jj_scan_token(CASE))
4091: return true;
4092: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4093: return false;
4094: if (jj_3R_44())
4095: return true;
4096: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4097: return false;
4098: return false;
4099: }
4100:
4101: final private boolean jj_3_2() {
4102: Token xsp;
4103: xsp = jj_scanpos;
4104: if (jj_3R_29()) {
4105: jj_scanpos = xsp;
4106: if (jj_3R_30())
4107: return true;
4108: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4109: return false;
4110: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4111: return false;
4112: return false;
4113: }
4114:
4115: final private boolean jj_3R_29() {
4116: if (jj_scan_token(PLUS))
4117: return true;
4118: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4119: return false;
4120: return false;
4121: }
4122:
4123: final private boolean jj_3R_124() {
4124: if (jj_scan_token(MINUS))
4125: return true;
4126: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4127: return false;
4128: return false;
4129: }
4130:
4131: final private boolean jj_3R_56() {
4132: if (jj_scan_token(WHITESPACE))
4133: return true;
4134: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4135: return false;
4136: return false;
4137: }
4138:
4139: final private boolean jj_3R_48() {
4140: Token xsp;
4141: xsp = jj_scanpos;
4142: if (jj_3R_56())
4143: jj_scanpos = xsp;
4144: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4145: return false;
4146: xsp = jj_scanpos;
4147: if (jj_3R_57()) {
4148: jj_scanpos = xsp;
4149: if (jj_3R_58())
4150: return true;
4151: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4152: return false;
4153: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4154: return false;
4155: if (jj_3R_59())
4156: return true;
4157: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4158: return false;
4159: return false;
4160: }
4161:
4162: final private boolean jj_3R_123() {
4163: if (jj_scan_token(PLUS))
4164: return true;
4165: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4166: return false;
4167: return false;
4168: }
4169:
4170: final private boolean jj_3R_91() {
4171: Token xsp;
4172: xsp = jj_scanpos;
4173: if (jj_3R_123()) {
4174: jj_scanpos = xsp;
4175: if (jj_3R_124())
4176: return true;
4177: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4178: return false;
4179: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4180: return false;
4181: if (jj_3R_90())
4182: return true;
4183: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4184: return false;
4185: return false;
4186: }
4187:
4188: final private boolean jj_3R_78() {
4189: if (jj_3R_90())
4190: return true;
4191: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4192: return false;
4193: Token xsp;
4194: while (true) {
4195: xsp = jj_scanpos;
4196: if (jj_3R_91()) {
4197: jj_scanpos = xsp;
4198: break;
4199: }
4200: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4201: return false;
4202: }
4203: return false;
4204: }
4205:
4206: final private boolean jj_3R_129() {
4207: if (jj_scan_token(LIST))
4208: return true;
4209: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4210: return false;
4211: return false;
4212: }
4213:
4214: final private boolean jj_3R_225() {
4215: if (jj_scan_token(BUILT_IN))
4216: return true;
4217: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4218: return false;
4219: if (jj_scan_token(ID))
4220: return true;
4221: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4222: return false;
4223: return false;
4224: }
4225:
4226: final private boolean jj_3R_184() {
4227: if (jj_scan_token(MINUS))
4228: return true;
4229: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4230: return false;
4231: return false;
4232: }
4233:
4234: final private boolean jj_3R_132() {
4235: if (jj_scan_token(INCLUDE))
4236: return true;
4237: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4238: return false;
4239: return false;
4240: }
4241:
4242: final private boolean jj_3R_183() {
4243: if (jj_scan_token(PLUS))
4244: return true;
4245: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4246: return false;
4247: return false;
4248: }
4249:
4250: final private boolean jj_3_15() {
4251: if (jj_3R_48())
4252: return true;
4253: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4254: return false;
4255: return false;
4256: }
4257:
4258: final private boolean jj_3R_180() {
4259: Token xsp;
4260: xsp = jj_scanpos;
4261: if (jj_3R_183()) {
4262: jj_scanpos = xsp;
4263: if (jj_3R_184())
4264: return true;
4265: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4266: return false;
4267: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4268: return false;
4269: if (jj_3R_182())
4270: return true;
4271: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4272: return false;
4273: return false;
4274: }
4275:
4276: final private boolean jj_3R_227() {
4277: if (jj_scan_token(EXISTS))
4278: return true;
4279: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4280: return false;
4281: return false;
4282: }
4283:
4284: final private boolean jj_3R_141() {
4285: if (jj_scan_token(SWITCH))
4286: return true;
4287: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4288: return false;
4289: return false;
4290: }
4291:
4292: final private boolean jj_3_10() {
4293: if (jj_3R_44())
4294: return true;
4295: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4296: return false;
4297: return false;
4298: }
4299:
4300: final private boolean jj_3R_185() {
4301: if (jj_scan_token(EXCLAM))
4302: return true;
4303: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4304: return false;
4305: return false;
4306: }
4307:
4308: final private boolean jj_3R_154() {
4309: if (jj_scan_token(ATTEMPT))
4310: return true;
4311: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4312: return false;
4313: return false;
4314: }
4315:
4316: final private boolean jj_3R_235() {
4317: if (jj_3R_44())
4318: return true;
4319: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4320: return false;
4321: return false;
4322: }
4323:
4324: final private boolean jj_3R_181() {
4325: Token xsp;
4326: if (jj_3R_185())
4327: return true;
4328: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4329: return false;
4330: while (true) {
4331: xsp = jj_scanpos;
4332: if (jj_3R_185()) {
4333: jj_scanpos = xsp;
4334: break;
4335: }
4336: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4337: return false;
4338: }
4339: if (jj_3R_182())
4340: return true;
4341: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4342: return false;
4343: return false;
4344: }
4345:
4346: final private boolean jj_3R_47() {
4347: if (jj_scan_token(STRING_LITERAL))
4348: return true;
4349: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4350: return false;
4351: return false;
4352: }
4353:
4354: final private boolean jj_3R_226() {
4355: if (jj_scan_token(EXCLAM))
4356: return true;
4357: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4358: return false;
4359: Token xsp;
4360: xsp = jj_scanpos;
4361: if (jj_3R_235())
4362: jj_scanpos = xsp;
4363: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4364: return false;
4365: return false;
4366: }
4367:
4368: final private boolean jj_3R_46() {
4369: if (jj_scan_token(ID))
4370: return true;
4371: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4372: return false;
4373: return false;
4374: }
4375:
4376: final private boolean jj_3R_217() {
4377: if (jj_3R_227())
4378: return true;
4379: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4380: return false;
4381: return false;
4382: }
4383:
4384: final private boolean jj_3R_216() {
4385: if (jj_3R_226())
4386: return true;
4387: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4388: return false;
4389: return false;
4390: }
4391:
4392: final private boolean jj_3R_215() {
4393: if (jj_3R_225())
4394: return true;
4395: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4396: return false;
4397: return false;
4398: }
4399:
4400: final private boolean jj_3R_45() {
4401: if (jj_scan_token(COMMA))
4402: return true;
4403: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4404: return false;
4405: return false;
4406: }
4407:
4408: final private boolean jj_3_11() {
4409: Token xsp;
4410: xsp = jj_scanpos;
4411: if (jj_3R_45())
4412: jj_scanpos = xsp;
4413: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4414: return false;
4415: xsp = jj_scanpos;
4416: if (jj_3R_46()) {
4417: jj_scanpos = xsp;
4418: if (jj_3R_47())
4419: return true;
4420: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4421: return false;
4422: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4423: return false;
4424: if (jj_scan_token(EQUALS))
4425: return true;
4426: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4427: return false;
4428: return false;
4429: }
4430:
4431: final private boolean jj_3R_214() {
4432: if (jj_3R_224())
4433: return true;
4434: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4435: return false;
4436: return false;
4437: }
4438:
4439: final private boolean jj_3R_140() {
4440: if (jj_scan_token(TRANSFORM))
4441: return true;
4442: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4443: return false;
4444: return false;
4445: }
4446:
4447: final private boolean jj_3R_213() {
4448: if (jj_3R_223())
4449: return true;
4450: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4451: return false;
4452: return false;
4453: }
4454:
4455: final private boolean jj_3R_62() {
4456: if (jj_3R_65())
4457: return true;
4458: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4459: return false;
4460: return false;
4461: }
4462:
4463: final private boolean jj_3R_212() {
4464: if (jj_3R_222())
4465: return true;
4466: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4467: return false;
4468: return false;
4469: }
4470:
4471: final private boolean jj_3R_203() {
4472: Token xsp;
4473: xsp = jj_scanpos;
4474: if (jj_3R_212()) {
4475: jj_scanpos = xsp;
4476: if (jj_3R_213()) {
4477: jj_scanpos = xsp;
4478: if (jj_3R_214()) {
4479: jj_scanpos = xsp;
4480: if (jj_3R_215()) {
4481: jj_scanpos = xsp;
4482: if (jj_3R_216()) {
4483: jj_scanpos = xsp;
4484: if (jj_3R_217())
4485: return true;
4486: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4487: return false;
4488: } else if (jj_la == 0
4489: && jj_scanpos == jj_lastpos)
4490: return false;
4491: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4492: return false;
4493: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4494: return false;
4495: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4496: return false;
4497: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4498: return false;
4499: return false;
4500: }
4501:
4502: final private boolean jj_3R_59() {
4503: Token xsp;
4504: xsp = jj_scanpos;
4505: if (jj_3R_62())
4506: jj_scanpos = xsp;
4507: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4508: return false;
4509: return false;
4510: }
4511:
4512: final private boolean jj_3R_157() {
4513: if (jj_3R_182())
4514: return true;
4515: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4516: return false;
4517: return false;
4518: }
4519:
4520: final private boolean jj_3R_156() {
4521: if (jj_3R_181())
4522: return true;
4523: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4524: return false;
4525: return false;
4526: }
4527:
4528: final private boolean jj_3R_139() {
4529: if (jj_scan_token(NOPARSE))
4530: return true;
4531: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4532: return false;
4533: return false;
4534: }
4535:
4536: final private boolean jj_3R_155() {
4537: if (jj_3R_180())
4538: return true;
4539: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4540: return false;
4541: return false;
4542: }
4543:
4544: final private boolean jj_3R_128() {
4545: if (jj_scan_token(IF))
4546: return true;
4547: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4548: return false;
4549: return false;
4550: }
4551:
4552: final private boolean jj_3R_121() {
4553: Token xsp;
4554: xsp = jj_scanpos;
4555: if (jj_3R_155()) {
4556: jj_scanpos = xsp;
4557: if (jj_3R_156()) {
4558: jj_scanpos = xsp;
4559: if (jj_3R_157())
4560: return true;
4561: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4562: return false;
4563: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4564: return false;
4565: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4566: return false;
4567: return false;
4568: }
4569:
4570: final private boolean jj_3R_167() {
4571: if (jj_scan_token(TERSE_COMMENT))
4572: return true;
4573: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4574: return false;
4575: return false;
4576: }
4577:
4578: final private boolean jj_3R_166() {
4579: if (jj_scan_token(COMMENT))
4580: return true;
4581: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4582: return false;
4583: return false;
4584: }
4585:
4586: final private boolean jj_3R_202() {
4587: if (jj_scan_token(DOT))
4588: return true;
4589: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4590: return false;
4591: if (jj_scan_token(ID))
4592: return true;
4593: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4594: return false;
4595: return false;
4596: }
4597:
4598: final private boolean jj_3R_163() {
4599: if (jj_scan_token(LOCALASSIGN))
4600: return true;
4601: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4602: return false;
4603: return false;
4604: }
4605:
4606: final private boolean jj_3R_162() {
4607: if (jj_scan_token(GLOBALASSIGN))
4608: return true;
4609: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4610: return false;
4611: return false;
4612: }
4613:
4614: final private boolean jj_3R_138() {
4615: Token xsp;
4616: xsp = jj_scanpos;
4617: if (jj_3R_166()) {
4618: jj_scanpos = xsp;
4619: if (jj_3R_167())
4620: return true;
4621: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4622: return false;
4623: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4624: return false;
4625: return false;
4626: }
4627:
4628: final private boolean jj_3R_161() {
4629: if (jj_scan_token(ASSIGN))
4630: return true;
4631: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4632: return false;
4633: return false;
4634: }
4635:
4636: final private boolean jj_3R_201() {
4637: if (jj_scan_token(OPEN_PAREN))
4638: return true;
4639: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4640: return false;
4641: if (jj_3R_44())
4642: return true;
4643: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4644: return false;
4645: if (jj_scan_token(CLOSE_PAREN))
4646: return true;
4647: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4648: return false;
4649: return false;
4650: }
4651:
4652: final private boolean jj_3R_131() {
4653: Token xsp;
4654: xsp = jj_scanpos;
4655: if (jj_3R_161()) {
4656: jj_scanpos = xsp;
4657: if (jj_3R_162()) {
4658: jj_scanpos = xsp;
4659: if (jj_3R_163())
4660: return true;
4661: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4662: return false;
4663: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4664: return false;
4665: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4666: return false;
4667: return false;
4668: }
4669:
4670: final private boolean jj_3R_28() {
4671: if (jj_scan_token(EXISTS))
4672: return true;
4673: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4674: return false;
4675: return false;
4676: }
4677:
4678: final private boolean jj_3R_27() {
4679: if (jj_scan_token(EXCLAM))
4680: return true;
4681: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4682: return false;
4683: return false;
4684: }
4685:
4686: final private boolean jj_3R_26() {
4687: if (jj_scan_token(BUILT_IN))
4688: return true;
4689: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4690: return false;
4691: return false;
4692: }
4693:
4694: final private boolean jj_3R_25() {
4695: if (jj_scan_token(OPEN_PAREN))
4696: return true;
4697: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4698: return false;
4699: return false;
4700: }
4701:
4702: final private boolean jj_3R_236() {
4703: if (jj_scan_token(COMMA))
4704: return true;
4705: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4706: return false;
4707: return false;
4708: }
4709:
4710: final private boolean jj_3R_24() {
4711: if (jj_scan_token(OPEN_BRACKET))
4712: return true;
4713: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4714: return false;
4715: return false;
4716: }
4717:
4718: final private boolean jj_3R_230() {
4719: Token xsp;
4720: xsp = jj_scanpos;
4721: if (jj_3R_236())
4722: jj_scanpos = xsp;
4723: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4724: return false;
4725: if (jj_3R_44())
4726: return true;
4727: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4728: return false;
4729: return false;
4730: }
4731:
4732: final private boolean jj_3_1() {
4733: Token xsp;
4734: xsp = jj_scanpos;
4735: if (jj_3R_23()) {
4736: jj_scanpos = xsp;
4737: if (jj_3R_24()) {
4738: jj_scanpos = xsp;
4739: if (jj_3R_25()) {
4740: jj_scanpos = xsp;
4741: if (jj_3R_26()) {
4742: jj_scanpos = xsp;
4743: if (jj_3R_27()) {
4744: jj_scanpos = xsp;
4745: if (jj_3R_28())
4746: return true;
4747: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4748: return false;
4749: } else if (jj_la == 0
4750: && jj_scanpos == jj_lastpos)
4751: return false;
4752: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4753: return false;
4754: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4755: return false;
4756: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4757: return false;
4758: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4759: return false;
4760: return false;
4761: }
4762:
4763: final private boolean jj_3R_23() {
4764: if (jj_scan_token(DOT))
4765: return true;
4766: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4767: return false;
4768: return false;
4769: }
4770:
4771: final private boolean jj_3R_221() {
4772: if (jj_3R_44())
4773: return true;
4774: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4775: return false;
4776: Token xsp;
4777: while (true) {
4778: xsp = jj_scanpos;
4779: if (jj_3R_230()) {
4780: jj_scanpos = xsp;
4781: break;
4782: }
4783: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4784: return false;
4785: }
4786: return false;
4787: }
4788:
4789: final private boolean jj_3R_211() {
4790: Token xsp;
4791: xsp = jj_scanpos;
4792: if (jj_3R_221())
4793: jj_scanpos = xsp;
4794: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4795: return false;
4796: return false;
4797: }
4798:
4799: final private boolean jj_3R_194() {
4800: if (jj_3R_203())
4801: return true;
4802: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4803: return false;
4804: return false;
4805: }
4806:
4807: final private boolean jj_3R_77() {
4808: if (jj_3R_89())
4809: return true;
4810: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4811: return false;
4812: return false;
4813: }
4814:
4815: final private boolean jj_3R_200() {
4816: if (jj_scan_token(ID))
4817: return true;
4818: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4819: return false;
4820: return false;
4821: }
4822:
4823: final private boolean jj_3R_193() {
4824: if (jj_3R_202())
4825: return true;
4826: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4827: return false;
4828: return false;
4829: }
4830:
4831: final private boolean jj_3R_175() {
4832: if (jj_scan_token(NOTRIM))
4833: return true;
4834: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4835: return false;
4836: return false;
4837: }
4838:
4839: final private boolean jj_3R_76() {
4840: if (jj_3R_88())
4841: return true;
4842: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4843: return false;
4844: return false;
4845: }
4846:
4847: final private boolean jj_3R_192() {
4848: if (jj_3R_201())
4849: return true;
4850: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4851: return false;
4852: return false;
4853: }
4854:
4855: final private boolean jj_3R_174() {
4856: if (jj_scan_token(RTRIM))
4857: return true;
4858: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4859: return false;
4860: return false;
4861: }
4862:
4863: final private boolean jj_3R_75() {
4864: if (jj_3R_87())
4865: return true;
4866: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4867: return false;
4868: return false;
4869: }
4870:
4871: final private boolean jj_3R_191() {
4872: if (jj_3R_200())
4873: return true;
4874: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4875: return false;
4876: return false;
4877: }
4878:
4879: final private boolean jj_3R_173() {
4880: if (jj_scan_token(LTRIM))
4881: return true;
4882: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4883: return false;
4884: return false;
4885: }
4886:
4887: final private boolean jj_3R_74() {
4888: if (jj_3R_86())
4889: return true;
4890: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4891: return false;
4892: return false;
4893: }
4894:
4895: final private boolean jj_3R_190() {
4896: if (jj_3R_199())
4897: return true;
4898: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4899: return false;
4900: return false;
4901: }
4902:
4903: final private boolean jj_3R_172() {
4904: if (jj_scan_token(TRIM))
4905: return true;
4906: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4907: return false;
4908: return false;
4909: }
4910:
4911: final private boolean jj_3R_189() {
4912: if (jj_3R_198())
4913: return true;
4914: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4915: return false;
4916: return false;
4917: }
4918:
4919: final private boolean jj_3R_147() {
4920: Token xsp;
4921: xsp = jj_scanpos;
4922: if (jj_3R_172()) {
4923: jj_scanpos = xsp;
4924: if (jj_3R_173()) {
4925: jj_scanpos = xsp;
4926: if (jj_3R_174()) {
4927: jj_scanpos = xsp;
4928: if (jj_3R_175())
4929: return true;
4930: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4931: return false;
4932: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4933: return false;
4934: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4935: return false;
4936: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4937: return false;
4938: return false;
4939: }
4940:
4941: final private boolean jj_3R_68() {
4942: Token xsp;
4943: xsp = jj_scanpos;
4944: if (jj_3R_74()) {
4945: jj_scanpos = xsp;
4946: if (jj_3R_75()) {
4947: jj_scanpos = xsp;
4948: if (jj_3R_76()) {
4949: jj_scanpos = xsp;
4950: if (jj_3R_77())
4951: return true;
4952: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4953: return false;
4954: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4955: return false;
4956: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4957: return false;
4958: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4959: return false;
4960: return false;
4961: }
4962:
4963: final private boolean jj_3R_188() {
4964: if (jj_3R_197())
4965: return true;
4966: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4967: return false;
4968: return false;
4969: }
4970:
4971: final private boolean jj_3R_187() {
4972: if (jj_3R_196())
4973: return true;
4974: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4975: return false;
4976: return false;
4977: }
4978:
4979: final private boolean jj_3R_65() {
4980: Token xsp;
4981: if (jj_3R_68())
4982: return true;
4983: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4984: return false;
4985: while (true) {
4986: xsp = jj_scanpos;
4987: if (jj_3R_68()) {
4988: jj_scanpos = xsp;
4989: break;
4990: }
4991: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4992: return false;
4993: }
4994: return false;
4995: }
4996:
4997: final private boolean jj_3R_205() {
4998: if (jj_scan_token(DECIMAL))
4999: return true;
5000: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5001: return false;
5002: return false;
5003: }
5004:
5005: final private boolean jj_3R_186() {
5006: if (jj_3R_195())
5007: return true;
5008: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5009: return false;
5010: return false;
5011: }
5012:
5013: final private boolean jj_3R_204() {
5014: if (jj_scan_token(INTEGER))
5015: return true;
5016: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5017: return false;
5018: return false;
5019: }
5020:
5021: final private boolean jj_3R_182() {
5022: Token xsp;
5023: xsp = jj_scanpos;
5024: if (jj_3R_186()) {
5025: jj_scanpos = xsp;
5026: if (jj_3R_187()) {
5027: jj_scanpos = xsp;
5028: if (jj_3R_188()) {
5029: jj_scanpos = xsp;
5030: if (jj_3R_189()) {
5031: jj_scanpos = xsp;
5032: if (jj_3R_190()) {
5033: jj_scanpos = xsp;
5034: if (jj_3R_191()) {
5035: jj_scanpos = xsp;
5036: if (jj_3R_192()) {
5037: jj_scanpos = xsp;
5038: if (jj_3R_193())
5039: return true;
5040: if (jj_la == 0
5041: && jj_scanpos == jj_lastpos)
5042: return false;
5043: } else if (jj_la == 0
5044: && jj_scanpos == jj_lastpos)
5045: return false;
5046: } else if (jj_la == 0
5047: && jj_scanpos == jj_lastpos)
5048: return false;
5049: } else if (jj_la == 0
5050: && jj_scanpos == jj_lastpos)
5051: return false;
5052: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5053: return false;
5054: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5055: return false;
5056: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5057: return false;
5058: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5059: return false;
5060: while (true) {
5061: xsp = jj_scanpos;
5062: if (jj_3R_194()) {
5063: jj_scanpos = xsp;
5064: break;
5065: }
5066: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5067: return false;
5068: }
5069: return false;
5070: }
5071:
5072: final private boolean jj_3R_195() {
5073: Token xsp;
5074: xsp = jj_scanpos;
5075: if (jj_3R_204()) {
5076: jj_scanpos = xsp;
5077: if (jj_3R_205())
5078: return true;
5079: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5080: return false;
5081: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5082: return false;
5083: return false;
5084: }
5085:
5086: final private boolean jj_3R_51() {
5087: if (jj_scan_token(FALSE_ALERT))
5088: return true;
5089: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5090: return false;
5091: return false;
5092: }
5093:
5094: final private boolean jj_3R_146() {
5095: if (jj_scan_token(FLUSH))
5096: return true;
5097: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5098: return false;
5099: return false;
5100: }
5101:
5102: final private boolean jj_3_13() {
5103: if (jj_scan_token(OPEN_PAREN))
5104: return true;
5105: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5106: return false;
5107: return false;
5108: }
5109:
5110: final private boolean jj_3R_199() {
5111: if (jj_scan_token(OPEN_BRACKET))
5112: return true;
5113: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5114: return false;
5115: if (jj_3R_211())
5116: return true;
5117: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5118: return false;
5119: if (jj_scan_token(CLOSE_BRACKET))
5120: return true;
5121: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5122: return false;
5123: return false;
5124: }
5125:
5126: final private boolean jj_3R_44() {
5127: if (jj_3R_55())
5128: return true;
5129: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5130: return false;
5131: return false;
5132: }
5133:
5134: final private boolean jj_3_14() {
5135: if (jj_scan_token(ID))
5136: return true;
5137: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5138: return false;
5139: if (jj_scan_token(EQUALS))
5140: return true;
5141: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5142: return false;
5143: return false;
5144: }
5145:
5146: final private boolean jj_3R_50() {
5147: if (jj_scan_token(PRINTABLE_CHARS))
5148: return true;
5149: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5150: return false;
5151: return false;
5152: }
5153:
5154: final private boolean jj_3_9() {
5155: if (jj_scan_token(OR))
5156: return true;
5157: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5158: return false;
5159: return false;
5160: }
5161:
5162: final private boolean jj_3R_177() {
5163: if (jj_scan_token(NESTED))
5164: return true;
5165: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5166: return false;
5167: return false;
5168: }
5169:
5170: final private boolean jj_3R_43() {
5171: if (jj_scan_token(LESS_THAN))
5172: return true;
5173: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5174: return false;
5175: return false;
5176: }
5177:
5178: final private boolean jj_3R_88() {
5179: if (jj_scan_token(NUMERICAL_ESCAPE))
5180: return true;
5181: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5182: return false;
5183: return false;
5184: }
5185:
5186: final private boolean jj_3R_137() {
5187: if (jj_scan_token(CALL))
5188: return true;
5189: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5190: return false;
5191: return false;
5192: }
5193:
5194: final private boolean jj_3R_49() {
5195: if (jj_scan_token(WHITESPACE))
5196: return true;
5197: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5198: return false;
5199: return false;
5200: }
5201:
5202: final private boolean jj_3_16() {
5203: Token xsp;
5204: xsp = jj_scanpos;
5205: if (jj_3R_49()) {
5206: jj_scanpos = xsp;
5207: if (jj_3R_50()) {
5208: jj_scanpos = xsp;
5209: if (jj_3R_51())
5210: return true;
5211: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5212: return false;
5213: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5214: return false;
5215: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5216: return false;
5217: return false;
5218: }
5219:
5220: final private boolean jj_3R_127() {
5221: if (jj_scan_token(FALSE_ALERT))
5222: return true;
5223: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5224: return false;
5225: return false;
5226: }
5227:
5228: final private boolean jj_3R_176() {
5229: if (jj_scan_token(SIMPLE_NESTED))
5230: return true;
5231: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5232: return false;
5233: return false;
5234: }
5235:
5236: final private boolean jj_3R_61() {
5237: if (jj_scan_token(OR))
5238: return true;
5239: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5240: return false;
5241: if (jj_3R_60())
5242: return true;
5243: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5244: return false;
5245: return false;
5246: }
5247:
5248: final private boolean jj_3R_126() {
5249: if (jj_scan_token(PRINTABLE_CHARS))
5250: return true;
5251: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5252: return false;
5253: return false;
5254: }
5255:
5256: final private boolean jj_3R_125() {
5257: if (jj_scan_token(WHITESPACE))
5258: return true;
5259: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5260: return false;
5261: return false;
5262: }
5263:
5264: final private boolean jj_3R_55() {
5265: if (jj_3R_60())
5266: return true;
5267: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5268: return false;
5269: Token xsp;
5270: while (true) {
5271: xsp = jj_scanpos;
5272: if (jj_3R_61()) {
5273: jj_scanpos = xsp;
5274: break;
5275: }
5276: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5277: return false;
5278: }
5279: return false;
5280: }
5281:
5282: final private boolean jj_3R_148() {
5283: Token xsp;
5284: xsp = jj_scanpos;
5285: if (jj_3R_176()) {
5286: jj_scanpos = xsp;
5287: if (jj_3R_177())
5288: return true;
5289: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5290: return false;
5291: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5292: return false;
5293: return false;
5294: }
5295:
5296: final private boolean jj_3R_93() {
5297: Token xsp;
5298: xsp = jj_scanpos;
5299: if (jj_3R_125()) {
5300: jj_scanpos = xsp;
5301: if (jj_3R_126()) {
5302: jj_scanpos = xsp;
5303: if (jj_3R_127())
5304: return true;
5305: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5306: return false;
5307: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5308: return false;
5309: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5310: return false;
5311: return false;
5312: }
5313:
5314: final private boolean jj_3R_86() {
5315: Token xsp;
5316: if (jj_3R_93())
5317: return true;
5318: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5319: return false;
5320: while (true) {
5321: xsp = jj_scanpos;
5322: if (jj_3R_93()) {
5323: jj_scanpos = xsp;
5324: break;
5325: }
5326: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5327: return false;
5328: }
5329: return false;
5330: }
5331:
5332: final private boolean jj_3_8() {
5333: if (jj_scan_token(AND))
5334: return true;
5335: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5336: return false;
5337: return false;
5338: }
5339:
5340: final private boolean jj_3R_42() {
5341: if (jj_scan_token(LESS_THAN_EQUALS))
5342: return true;
5343: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5344: return false;
5345: return false;
5346: }
5347:
5348: final private boolean jj_3R_87() {
5349: if (jj_scan_token(OUTPUT_ESCAPE))
5350: return true;
5351: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5352: return false;
5353: return false;
5354: }
5355:
5356: final private boolean jj_3R_171() {
5357: if (jj_scan_token(STOP))
5358: return true;
5359: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5360: return false;
5361: return false;
5362: }
5363:
5364: final private boolean jj_3R_170() {
5365: if (jj_scan_token(HALT))
5366: return true;
5367: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5368: return false;
5369: return false;
5370: }
5371:
5372: final private boolean jj_3R_64() {
5373: if (jj_scan_token(AND))
5374: return true;
5375: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5376: return false;
5377: if (jj_3R_63())
5378: return true;
5379: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5380: return false;
5381: return false;
5382: }
5383:
5384: final private boolean jj_3R_145() {
5385: Token xsp;
5386: xsp = jj_scanpos;
5387: if (jj_3R_170()) {
5388: jj_scanpos = xsp;
5389: if (jj_3R_171())
5390: return true;
5391: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5392: return false;
5393: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5394: return false;
5395: return false;
5396: }
5397:
5398: final private boolean jj_3R_229() {
5399: if (jj_scan_token(COLON))
5400: return true;
5401: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5402: return false;
5403: return false;
5404: }
5405:
5406: final private boolean jj_3R_60() {
5407: if (jj_3R_63())
5408: return true;
5409: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5410: return false;
5411: Token xsp;
5412: while (true) {
5413: xsp = jj_scanpos;
5414: if (jj_3R_64()) {
5415: jj_scanpos = xsp;
5416: break;
5417: }
5418: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5419: return false;
5420: }
5421: return false;
5422: }
5423:
5424: final private boolean jj_3R_120() {
5425: if (jj_3R_154())
5426: return true;
5427: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5428: return false;
5429: return false;
5430: }
5431:
5432: final private boolean jj_3R_119() {
5433: if (jj_3R_153())
5434: return true;
5435: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5436: return false;
5437: return false;
5438: }
5439:
5440: final private boolean jj_3R_41() {
5441: if (jj_scan_token(LESS_THAN_EQUALS))
5442: return true;
5443: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5444: return false;
5445: return false;
5446: }
5447:
5448: final private boolean jj_3R_118() {
5449: if (jj_3R_152())
5450: return true;
5451: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5452: return false;
5453: return false;
5454: }
5455:
5456: final private boolean jj_3R_228() {
5457: if (jj_scan_token(COMMA))
5458: return true;
5459: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5460: return false;
5461: return false;
5462: }
5463:
5464: final private boolean jj_3R_117() {
5465: if (jj_3R_151())
5466: return true;
5467: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5468: return false;
5469: return false;
5470: }
5471:
5472: final private boolean jj_3_12() {
5473: if (jj_scan_token(ID))
5474: return true;
5475: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5476: return false;
5477: if (jj_scan_token(EQUALS))
5478: return true;
5479: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5480: return false;
5481: return false;
5482: }
5483:
5484: final private boolean jj_3R_116() {
5485: if (jj_3R_150())
5486: return true;
5487: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5488: return false;
5489: return false;
5490: }
5491:
5492: final private boolean jj_3R_220() {
5493: if (jj_scan_token(COMMA))
5494: return true;
5495: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5496: return false;
5497: if (jj_3R_44())
5498: return true;
5499: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5500: return false;
5501: Token xsp;
5502: xsp = jj_scanpos;
5503: if (jj_3R_228()) {
5504: jj_scanpos = xsp;
5505: if (jj_3R_229())
5506: return true;
5507: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5508: return false;
5509: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5510: return false;
5511: if (jj_3R_44())
5512: return true;
5513: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5514: return false;
5515: return false;
5516: }
5517:
5518: final private boolean jj_3R_115() {
5519: if (jj_3R_149())
5520: return true;
5521: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5522: return false;
5523: return false;
5524: }
5525:
5526: final private boolean jj_3R_219() {
5527: if (jj_scan_token(COLON))
5528: return true;
5529: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5530: return false;
5531: return false;
5532: }
5533:
5534: final private boolean jj_3R_114() {
5535: if (jj_3R_148())
5536: return true;
5537: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5538: return false;
5539: return false;
5540: }
5541:
5542: final private boolean jj_3_6() {
5543: if (jj_3R_44())
5544: return true;
5545: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5546: return false;
5547: return false;
5548: }
5549:
5550: final private boolean jj_3R_113() {
5551: if (jj_3R_147())
5552: return true;
5553: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5554: return false;
5555: return false;
5556: }
5557:
5558: final private boolean jj_3R_112() {
5559: if (jj_3R_146())
5560: return true;
5561: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5562: return false;
5563: return false;
5564: }
5565:
5566: final private boolean jj_3R_40() {
5567: if (jj_scan_token(ESCAPED_GT))
5568: return true;
5569: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5570: return false;
5571: return false;
5572: }
5573:
5574: final private boolean jj_3R_111() {
5575: if (jj_3R_145())
5576: return true;
5577: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5578: return false;
5579: return false;
5580: }
5581:
5582: final private boolean jj_3_7() {
5583: if (jj_scan_token(DOT_DOT))
5584: return true;
5585: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5586: return false;
5587: return false;
5588: }
5589:
5590: final private boolean jj_3R_218() {
5591: if (jj_scan_token(COMMA))
5592: return true;
5593: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5594: return false;
5595: return false;
5596: }
5597:
5598: final private boolean jj_3R_110() {
5599: if (jj_3R_144())
5600: return true;
5601: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5602: return false;
5603: return false;
5604: }
5605:
5606: final private boolean jj_3R_206() {
5607: if (jj_3R_44())
5608: return true;
5609: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5610: return false;
5611: Token xsp;
5612: xsp = jj_scanpos;
5613: if (jj_3R_218()) {
5614: jj_scanpos = xsp;
5615: if (jj_3R_219())
5616: return true;
5617: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5618: return false;
5619: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5620: return false;
5621: if (jj_3R_44())
5622: return true;
5623: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5624: return false;
5625: while (true) {
5626: xsp = jj_scanpos;
5627: if (jj_3R_220()) {
5628: jj_scanpos = xsp;
5629: break;
5630: }
5631: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5632: return false;
5633: }
5634: return false;
5635: }
5636:
5637: final private boolean jj_3R_109() {
5638: if (jj_3R_143())
5639: return true;
5640: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5641: return false;
5642: return false;
5643: }
5644:
5645: final private boolean jj_3R_92() {
5646: if (jj_3R_78())
5647: return true;
5648: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5649: return false;
5650: return false;
5651: }
5652:
5653: final private boolean jj_3R_108() {
5654: if (jj_3R_142())
5655: return true;
5656: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5657: return false;
5658: return false;
5659: }
5660:
5661: final private boolean jj_3R_107() {
5662: if (jj_3R_141())
5663: return true;
5664: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5665: return false;
5666: return false;
5667: }
5668:
5669: final private boolean jj_3R_196() {
5670: if (jj_scan_token(OPEN_BRACE))
5671: return true;
5672: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5673: return false;
5674: Token xsp;
5675: xsp = jj_scanpos;
5676: if (jj_3R_206())
5677: jj_scanpos = xsp;
5678: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5679: return false;
5680: if (jj_scan_token(CLOSE_BRACE))
5681: return true;
5682: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5683: return false;
5684: return false;
5685: }
5686:
5687: final private boolean jj_3R_169() {
5688: if (jj_scan_token(RETURN))
5689: return true;
5690: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5691: return false;
5692: return false;
5693: }
5694:
5695: final private boolean jj_3R_106() {
5696: if (jj_3R_140())
5697: return true;
5698: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5699: return false;
5700: return false;
5701: }
5702:
5703: final private boolean jj_3R_79() {
5704: if (jj_scan_token(DOT_DOT))
5705: return true;
5706: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5707: return false;
5708: Token xsp;
5709: xsp = jj_scanpos;
5710: if (jj_3R_92())
5711: jj_scanpos = xsp;
5712: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5713: return false;
5714: return false;
5715: }
5716:
5717: final private boolean jj_3R_136() {
5718: if (jj_scan_token(UNIFIED_CALL))
5719: return true;
5720: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5721: return false;
5722: return false;
5723: }
5724:
5725: final private boolean jj_3R_168() {
5726: if (jj_scan_token(SIMPLE_RETURN))
5727: return true;
5728: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5729: return false;
5730: return false;
5731: }
5732:
5733: final private boolean jj_3R_39() {
5734: if (jj_scan_token(NATURAL_GT))
5735: return true;
5736: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5737: return false;
5738: return false;
5739: }
5740:
5741: final private boolean jj_3R_105() {
5742: if (jj_3R_139())
5743: return true;
5744: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5745: return false;
5746: return false;
5747: }
5748:
5749: final private boolean jj_3R_104() {
5750: if (jj_3R_138())
5751: return true;
5752: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5753: return false;
5754: return false;
5755: }
5756:
5757: final private boolean jj_3R_69() {
5758: if (jj_3R_78())
5759: return true;
5760: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5761: return false;
5762: Token xsp;
5763: xsp = jj_scanpos;
5764: if (jj_3R_79())
5765: jj_scanpos = xsp;
5766: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5767: return false;
5768: return false;
5769: }
5770:
5771: final private boolean jj_3R_144() {
5772: Token xsp;
5773: xsp = jj_scanpos;
5774: if (jj_3R_168()) {
5775: jj_scanpos = xsp;
5776: if (jj_3R_169())
5777: return true;
5778: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5779: return false;
5780: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5781: return false;
5782: return false;
5783: }
5784:
5785: final private boolean jj_3R_103() {
5786: if (jj_3R_137())
5787: return true;
5788: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5789: return false;
5790: return false;
5791: }
5792:
5793: final private boolean jj_3R_102() {
5794: if (jj_3R_136())
5795: return true;
5796: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5797: return false;
5798: return false;
5799: }
5800:
5801: final private boolean jj_3R_101() {
5802: if (jj_3R_135())
5803: return true;
5804: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5805: return false;
5806: return false;
5807: }
5808:
5809: final private boolean jj_3R_100() {
5810: if (jj_3R_134())
5811: return true;
5812: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5813: return false;
5814: return false;
5815: }
5816:
5817: final private boolean jj_3R_210() {
5818: if (jj_scan_token(TRUE))
5819: return true;
5820: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5821: return false;
5822: return false;
5823: }
5824:
5825: final private boolean jj_3R_99() {
5826: if (jj_3R_133())
5827: return true;
5828: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5829: return false;
5830: return false;
5831: }
5832:
5833: final private boolean jj_3R_209() {
5834: if (jj_scan_token(FALSE))
5835: return true;
5836: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5837: return false;
5838: return false;
5839: }
5840:
5841: final private boolean jj_3R_38() {
5842: if (jj_scan_token(ESCAPED_GTE))
5843: return true;
5844: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5845: return false;
5846: return false;
5847: }
5848:
5849: final private boolean jj_3R_98() {
5850: if (jj_3R_132())
5851: return true;
5852: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5853: return false;
5854: return false;
5855: }
5856:
5857: final private boolean jj_3R_97() {
5858: if (jj_3R_131())
5859: return true;
5860: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5861: return false;
5862: return false;
5863: }
5864:
5865: final private boolean jj_3R_198() {
5866: Token xsp;
5867: xsp = jj_scanpos;
5868: if (jj_3R_209()) {
5869: jj_scanpos = xsp;
5870: if (jj_3R_210())
5871: return true;
5872: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5873: return false;
5874: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5875: return false;
5876: return false;
5877: }
5878:
5879: final private boolean jj_3R_96() {
5880: if (jj_3R_130())
5881: return true;
5882: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5883: return false;
5884: return false;
5885: }
5886:
5887: final private boolean jj_3R_135() {
5888: if (jj_scan_token(COMPRESS))
5889: return true;
5890: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5891: return false;
5892: return false;
5893: }
5894:
5895: final private boolean jj_3R_95() {
5896: if (jj_3R_129())
5897: return true;
5898: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5899: return false;
5900: return false;
5901: }
5902:
5903: final private boolean jj_3R_94() {
5904: if (jj_3R_128())
5905: return true;
5906: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5907: return false;
5908: return false;
5909: }
5910:
5911: final private boolean jj_3R_54() {
5912: if (jj_scan_token(FTL_HEADER))
5913: return true;
5914: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5915: return false;
5916: return false;
5917: }
5918:
5919: final private boolean jj_3R_85() {
5920: if (jj_scan_token(LESS_THAN))
5921: return true;
5922: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5923: return false;
5924: return false;
5925: }
5926:
5927: final private boolean jj_3R_89() {
5928: Token xsp;
5929: xsp = jj_scanpos;
5930: if (jj_3R_94()) {
5931: jj_scanpos = xsp;
5932: if (jj_3R_95()) {
5933: jj_scanpos = xsp;
5934: if (jj_3R_96()) {
5935: jj_scanpos = xsp;
5936: if (jj_3R_97()) {
5937: jj_scanpos = xsp;
5938: if (jj_3R_98()) {
5939: jj_scanpos = xsp;
5940: if (jj_3R_99()) {
5941: jj_scanpos = xsp;
5942: if (jj_3R_100()) {
5943: jj_scanpos = xsp;
5944: if (jj_3R_101()) {
5945: jj_scanpos = xsp;
5946: if (jj_3R_102()) {
5947: jj_scanpos = xsp;
5948: if (jj_3R_103()) {
5949: jj_scanpos = xsp;
5950: if (jj_3R_104()) {
5951: jj_scanpos = xsp;
5952: if (jj_3R_105()) {
5953: jj_scanpos = xsp;
5954: if (jj_3R_106()) {
5955: jj_scanpos = xsp;
5956: if (jj_3R_107()) {
5957: jj_scanpos = xsp;
5958: if (jj_3R_108()) {
5959: jj_scanpos = xsp;
5960: if (jj_3R_109()) {
5961: jj_scanpos = xsp;
5962: if (jj_3R_110()) {
5963: jj_scanpos = xsp;
5964: if (jj_3R_111()) {
5965: jj_scanpos = xsp;
5966: if (jj_3R_112()) {
5967: jj_scanpos = xsp;
5968: if (jj_3R_113()) {
5969: jj_scanpos = xsp;
5970: if (jj_3R_114()) {
5971: jj_scanpos = xsp;
5972: if (jj_3R_115()) {
5973: jj_scanpos = xsp;
5974: if (jj_3R_116()) {
5975: jj_scanpos = xsp;
5976: if (jj_3R_117()) {
5977: jj_scanpos = xsp;
5978: if (jj_3R_118()) {
5979: jj_scanpos = xsp;
5980: if (jj_3R_119()) {
5981: jj_scanpos = xsp;
5982: if (jj_3R_120())
5983: return true;
5984: if (jj_la == 0
5985: && jj_scanpos == jj_lastpos)
5986: return false;
5987: } else if (jj_la == 0
5988: && jj_scanpos == jj_lastpos)
5989: return false;
5990: } else if (jj_la == 0
5991: && jj_scanpos == jj_lastpos)
5992: return false;
5993: } else if (jj_la == 0
5994: && jj_scanpos == jj_lastpos)
5995: return false;
5996: } else if (jj_la == 0
5997: && jj_scanpos == jj_lastpos)
5998: return false;
5999: } else if (jj_la == 0
6000: && jj_scanpos == jj_lastpos)
6001: return false;
6002: } else if (jj_la == 0
6003: && jj_scanpos == jj_lastpos)
6004: return false;
6005: } else if (jj_la == 0
6006: && jj_scanpos == jj_lastpos)
6007: return false;
6008: } else if (jj_la == 0
6009: && jj_scanpos == jj_lastpos)
6010: return false;
6011: } else if (jj_la == 0
6012: && jj_scanpos == jj_lastpos)
6013: return false;
6014: } else if (jj_la == 0
6015: && jj_scanpos == jj_lastpos)
6016: return false;
6017: } else if (jj_la == 0
6018: && jj_scanpos == jj_lastpos)
6019: return false;
6020: } else if (jj_la == 0
6021: && jj_scanpos == jj_lastpos)
6022: return false;
6023: } else if (jj_la == 0
6024: && jj_scanpos == jj_lastpos)
6025: return false;
6026: } else if (jj_la == 0
6027: && jj_scanpos == jj_lastpos)
6028: return false;
6029: } else if (jj_la == 0
6030: && jj_scanpos == jj_lastpos)
6031: return false;
6032: } else if (jj_la == 0
6033: && jj_scanpos == jj_lastpos)
6034: return false;
6035: } else if (jj_la == 0
6036: && jj_scanpos == jj_lastpos)
6037: return false;
6038: } else if (jj_la == 0
6039: && jj_scanpos == jj_lastpos)
6040: return false;
6041: } else if (jj_la == 0
6042: && jj_scanpos == jj_lastpos)
6043: return false;
6044: } else if (jj_la == 0
6045: && jj_scanpos == jj_lastpos)
6046: return false;
6047: } else if (jj_la == 0
6048: && jj_scanpos == jj_lastpos)
6049: return false;
6050: } else if (jj_la == 0
6051: && jj_scanpos == jj_lastpos)
6052: return false;
6053: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6054: return false;
6055: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6056: return false;
6057: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6058: return false;
6059: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6060: return false;
6061: return false;
6062: }
6063:
6064: final private boolean jj_3R_84() {
6065: if (jj_scan_token(LESS_THAN_EQUALS))
6066: return true;
6067: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6068: return false;
6069: return false;
6070: }
6071:
6072: final private boolean jj_3_5() {
6073: Token xsp;
6074: xsp = jj_scanpos;
6075: if (jj_3R_37()) {
6076: jj_scanpos = xsp;
6077: if (jj_3R_38()) {
6078: jj_scanpos = xsp;
6079: if (jj_3R_39()) {
6080: jj_scanpos = xsp;
6081: if (jj_3R_40()) {
6082: jj_scanpos = xsp;
6083: if (jj_3R_41()) {
6084: jj_scanpos = xsp;
6085: if (jj_3R_42()) {
6086: jj_scanpos = xsp;
6087: if (jj_3R_43())
6088: return true;
6089: if (jj_la == 0
6090: && jj_scanpos == jj_lastpos)
6091: return false;
6092: } else if (jj_la == 0
6093: && jj_scanpos == jj_lastpos)
6094: return false;
6095: } else if (jj_la == 0
6096: && jj_scanpos == jj_lastpos)
6097: return false;
6098: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6099: return false;
6100: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6101: return false;
6102: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6103: return false;
6104: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6105: return false;
6106: return false;
6107: }
6108:
6109: final private boolean jj_3R_37() {
6110: if (jj_scan_token(NATURAL_GTE))
6111: return true;
6112: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6113: return false;
6114: return false;
6115: }
6116:
6117: final private boolean jj_3R_143() {
6118: if (jj_scan_token(BREAK))
6119: return true;
6120: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6121: return false;
6122: return false;
6123: }
6124:
6125: final private boolean jj_3R_83() {
6126: if (jj_scan_token(ESCAPED_GT))
6127: return true;
6128: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6129: return false;
6130: return false;
6131: }
6132:
6133: final private boolean jj_3R_82() {
6134: if (jj_scan_token(NATURAL_GT))
6135: return true;
6136: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6137: return false;
6138: return false;
6139: }
6140:
6141: final private boolean jj_3R_36() {
6142: if (jj_scan_token(DOUBLE_EQUALS))
6143: return true;
6144: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6145: return false;
6146: return false;
6147: }
6148:
6149: final private boolean jj_3R_81() {
6150: if (jj_scan_token(ESCAPED_GTE))
6151: return true;
6152: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6153: return false;
6154: return false;
6155: }
6156:
6157: final private boolean jj_3R_80() {
6158: if (jj_scan_token(NATURAL_GTE))
6159: return true;
6160: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6161: return false;
6162: return false;
6163: }
6164:
6165: final private boolean jj_3R_70() {
6166: Token xsp;
6167: xsp = jj_scanpos;
6168: if (jj_3R_80()) {
6169: jj_scanpos = xsp;
6170: if (jj_3R_81()) {
6171: jj_scanpos = xsp;
6172: if (jj_3R_82()) {
6173: jj_scanpos = xsp;
6174: if (jj_3R_83()) {
6175: jj_scanpos = xsp;
6176: if (jj_3R_84()) {
6177: jj_scanpos = xsp;
6178: if (jj_3R_85())
6179: return true;
6180: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6181: return false;
6182: } else if (jj_la == 0
6183: && jj_scanpos == jj_lastpos)
6184: return false;
6185: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6186: return false;
6187: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6188: return false;
6189: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6190: return false;
6191: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6192: return false;
6193: if (jj_3R_69())
6194: return true;
6195: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6196: return false;
6197: return false;
6198: }
6199:
6200: final private boolean jj_3R_66() {
6201: if (jj_3R_69())
6202: return true;
6203: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6204: return false;
6205: Token xsp;
6206: xsp = jj_scanpos;
6207: if (jj_3R_70())
6208: jj_scanpos = xsp;
6209: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6210: return false;
6211: return false;
6212: }
6213:
6214: final private boolean jj_3R_35() {
6215: if (jj_scan_token(EQUALS))
6216: return true;
6217: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6218: return false;
6219: return false;
6220: }
6221:
6222: public FMParserTokenManager token_source;
6223: SimpleCharStream jj_input_stream;
6224: public Token token, jj_nt;
6225: private int jj_ntk;
6226: private Token jj_scanpos, jj_lastpos;
6227: private int jj_la;
6228: public boolean lookingAhead = false;
6229: private boolean jj_semLA;
6230: private int jj_gen;
6231: final private int[] jj_la1 = new int[79];
6232: final private int[] jj_la1_0 = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6233: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6234: 0x0, 0x200, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1000000,
6235: 0x800000, 0x0, 0x0, 0x1c000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6236: 0x0, 0x180000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6237: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30000000, 0x0,
6238: 0x0, 0x0, 0x0, 0x0, 0x2000, 0x0, 0x7fffdd40, 0x0, 0x0, 0x0,
6239: 0x7fffdd40, 0x7fffdd40, 0x0, 0x0, 0x7fffdd40, 0x0, 0x0,
6240: 0x0, 0x0, 0x0, };
6241: final private int[] jj_la1_1 = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6242: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6243: 0x0, 0x0, 0x1000, 0x6, 0x0, 0x0, 0x0, 0x3000000, 0x4000,
6244: 0x8000, 0xc00000, 0x1e0000, 0x0, 0x0, 0x0, 0x0, 0x70, 0x0,
6245: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x180, 0x0,
6246: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6247: 0x0, 0x0, 0x0, 0x200000, 0x0, 0xafdfe000, 0x0, 0x0, 0x0,
6248: 0xafdfe000, 0xafdfe000, 0x0, 0x0, 0xafdfe000, 0x0, 0x0,
6249: 0x0, 0x0, 0x0, };
6250: final private int[] jj_la1_2 = { 0xfe0000, 0xfe0000, 0x0, 0x0, 0x0,
6251: 0x0, 0x38000000, 0xc0000000, 0x600000, 0x60000, 0x6800000,
6252: 0xc0180000, 0xc0180000, 0x60000, 0x180000, 0x0, 0x0, 0x0,
6253: 0xfe0000, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfe0000, 0x0, 0x0, 0x0,
6254: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8000000, 0x0,
6255: 0x0, 0x0, 0x0, 0x0, 0x0, 0x8000000, 0x0, 0x0, 0x0, 0x0,
6256: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfe0000, 0x0, 0xfe0000, 0x0,
6257: 0x0, 0x0, 0x0, 0x10, 0x10, 0x0, 0x0, 0x0, 0x70, 0x0, 0x0,
6258: 0x1f0, 0x1f0, 0x1f0, 0x1f0, 0x1f0, 0x10, 0x0, 0x6, 0x0,
6259: 0x0, };
6260: final private int[] jj_la1_3 = { 0x10a8000, 0x10a880c, 0x800, 0xc,
6261: 0xc, 0x190, 0x0, 0x60000003, 0x0, 0x1000000, 0x28800,
6262: 0xe00003, 0x1e00033, 0x0, 0x0, 0x5000, 0x1000, 0x5000,
6263: 0x10a880c, 0x2000, 0x0, 0x0, 0x0, 0x800000, 0x10a880c,
6264: 0x800000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1000, 0x200000,
6265: 0x200000, 0x0, 0x8200000, 0x2000, 0x1000000, 0x0, 0x20000,
6266: 0x1000000, 0x40, 0x0, 0x1000, 0x40000, 0x0, 0x80000000,
6267: 0x1000, 0x1000000, 0x2000, 0x18000000, 0x40000, 0x1000000,
6268: 0x10a980c, 0x1000, 0x10a880c, 0x0, 0x2000, 0x1000000,
6269: 0x18000000, 0x0, 0x0, 0x0, 0x18000000, 0x0, 0x0, 0x0, 0x0,
6270: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1000000, 0x0, 0x1000,
6271: 0x1000000, };
6272: final private int[] jj_la1_4 = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6273: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6274: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6275: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6276: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6277: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6278: 0xf, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, };
6279: final private JJCalls[] jj_2_rtns = new JJCalls[17];
6280: private boolean jj_rescan = false;
6281: private int jj_gc = 0;
6282:
6283: public FMParser(java.io.InputStream stream) {
6284: jj_input_stream = new SimpleCharStream(stream, 1, 1);
6285: token_source = new FMParserTokenManager(jj_input_stream);
6286: token = new Token();
6287: jj_ntk = -1;
6288: jj_gen = 0;
6289: for (int i = 0; i < 79; i++)
6290: jj_la1[i] = -1;
6291: for (int i = 0; i < jj_2_rtns.length; i++)
6292: jj_2_rtns[i] = new JJCalls();
6293: }
6294:
6295: public void ReInit(java.io.InputStream stream) {
6296: jj_input_stream.ReInit(stream, 1, 1);
6297: token_source.ReInit(jj_input_stream);
6298: token = new Token();
6299: jj_ntk = -1;
6300: jj_gen = 0;
6301: for (int i = 0; i < 79; i++)
6302: jj_la1[i] = -1;
6303: for (int i = 0; i < jj_2_rtns.length; i++)
6304: jj_2_rtns[i] = new JJCalls();
6305: }
6306:
6307: public FMParser(java.io.Reader stream) {
6308: jj_input_stream = new SimpleCharStream(stream, 1, 1);
6309: token_source = new FMParserTokenManager(jj_input_stream);
6310: token = new Token();
6311: jj_ntk = -1;
6312: jj_gen = 0;
6313: for (int i = 0; i < 79; i++)
6314: jj_la1[i] = -1;
6315: for (int i = 0; i < jj_2_rtns.length; i++)
6316: jj_2_rtns[i] = new JJCalls();
6317: }
6318:
6319: public void ReInit(java.io.Reader stream) {
6320: jj_input_stream.ReInit(stream, 1, 1);
6321: token_source.ReInit(jj_input_stream);
6322: token = new Token();
6323: jj_ntk = -1;
6324: jj_gen = 0;
6325: for (int i = 0; i < 79; i++)
6326: jj_la1[i] = -1;
6327: for (int i = 0; i < jj_2_rtns.length; i++)
6328: jj_2_rtns[i] = new JJCalls();
6329: }
6330:
6331: public FMParser(FMParserTokenManager tm) {
6332: token_source = tm;
6333: token = new Token();
6334: jj_ntk = -1;
6335: jj_gen = 0;
6336: for (int i = 0; i < 79; i++)
6337: jj_la1[i] = -1;
6338: for (int i = 0; i < jj_2_rtns.length; i++)
6339: jj_2_rtns[i] = new JJCalls();
6340: }
6341:
6342: public void ReInit(FMParserTokenManager tm) {
6343: token_source = tm;
6344: token = new Token();
6345: jj_ntk = -1;
6346: jj_gen = 0;
6347: for (int i = 0; i < 79; i++)
6348: jj_la1[i] = -1;
6349: for (int i = 0; i < jj_2_rtns.length; i++)
6350: jj_2_rtns[i] = new JJCalls();
6351: }
6352:
6353: final private Token jj_consume_token(int kind)
6354: throws ParseException {
6355: Token oldToken;
6356: if ((oldToken = token).next != null)
6357: token = token.next;
6358: else
6359: token = token.next = token_source.getNextToken();
6360: jj_ntk = -1;
6361: if (token.kind == kind) {
6362: jj_gen++;
6363: if (++jj_gc > 100) {
6364: jj_gc = 0;
6365: for (int i = 0; i < jj_2_rtns.length; i++) {
6366: JJCalls c = jj_2_rtns[i];
6367: while (c != null) {
6368: if (c.gen < jj_gen)
6369: c.first = null;
6370: c = c.next;
6371: }
6372: }
6373: }
6374: return token;
6375: }
6376: token = oldToken;
6377: jj_kind = kind;
6378: throw generateParseException();
6379: }
6380:
6381: final private boolean jj_scan_token(int kind) {
6382: if (jj_scanpos == jj_lastpos) {
6383: jj_la--;
6384: if (jj_scanpos.next == null) {
6385: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
6386: .getNextToken();
6387: } else {
6388: jj_lastpos = jj_scanpos = jj_scanpos.next;
6389: }
6390: } else {
6391: jj_scanpos = jj_scanpos.next;
6392: }
6393: if (jj_rescan) {
6394: int i = 0;
6395: Token tok = token;
6396: while (tok != null && tok != jj_scanpos) {
6397: i++;
6398: tok = tok.next;
6399: }
6400: if (tok != null)
6401: jj_add_error_token(kind, i);
6402: }
6403: return (jj_scanpos.kind != kind);
6404: }
6405:
6406: final public Token getNextToken() {
6407: if (token.next != null)
6408: token = token.next;
6409: else
6410: token = token.next = token_source.getNextToken();
6411: jj_ntk = -1;
6412: jj_gen++;
6413: return token;
6414: }
6415:
6416: final public Token getToken(int index) {
6417: Token t = lookingAhead ? jj_scanpos : token;
6418: for (int i = 0; i < index; i++) {
6419: if (t.next != null)
6420: t = t.next;
6421: else
6422: t = t.next = token_source.getNextToken();
6423: }
6424: return t;
6425: }
6426:
6427: final private int jj_ntk() {
6428: if ((jj_nt = token.next) == null)
6429: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
6430: else
6431: return (jj_ntk = jj_nt.kind);
6432: }
6433:
6434: private java.util.Vector jj_expentries = new java.util.Vector();
6435: private int[] jj_expentry;
6436: private int jj_kind = -1;
6437: private int[] jj_lasttokens = new int[100];
6438: private int jj_endpos;
6439:
6440: private void jj_add_error_token(int kind, int pos) {
6441: if (pos >= 100)
6442: return;
6443: if (pos == jj_endpos + 1) {
6444: jj_lasttokens[jj_endpos++] = kind;
6445: } else if (jj_endpos != 0) {
6446: jj_expentry = new int[jj_endpos];
6447: for (int i = 0; i < jj_endpos; i++) {
6448: jj_expentry[i] = jj_lasttokens[i];
6449: }
6450: boolean exists = false;
6451: for (java.util.Enumeration ENUM = jj_expentries.elements(); ENUM
6452: .hasMoreElements();) {
6453: int[] oldentry = (int[]) (ENUM.nextElement());
6454: if (oldentry.length == jj_expentry.length) {
6455: exists = true;
6456: for (int i = 0; i < jj_expentry.length; i++) {
6457: if (oldentry[i] != jj_expentry[i]) {
6458: exists = false;
6459: break;
6460: }
6461: }
6462: if (exists)
6463: break;
6464: }
6465: }
6466: if (!exists)
6467: jj_expentries.addElement(jj_expentry);
6468: if (pos != 0)
6469: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
6470: }
6471: }
6472:
6473: final public ParseException generateParseException() {
6474: jj_expentries.removeAllElements();
6475: boolean[] la1tokens = new boolean[132];
6476: for (int i = 0; i < 132; i++) {
6477: la1tokens[i] = false;
6478: }
6479: if (jj_kind >= 0) {
6480: la1tokens[jj_kind] = true;
6481: jj_kind = -1;
6482: }
6483: for (int i = 0; i < 79; i++) {
6484: if (jj_la1[i] == jj_gen) {
6485: for (int j = 0; j < 32; j++) {
6486: if ((jj_la1_0[i] & (1 << j)) != 0) {
6487: la1tokens[j] = true;
6488: }
6489: if ((jj_la1_1[i] & (1 << j)) != 0) {
6490: la1tokens[32 + j] = true;
6491: }
6492: if ((jj_la1_2[i] & (1 << j)) != 0) {
6493: la1tokens[64 + j] = true;
6494: }
6495: if ((jj_la1_3[i] & (1 << j)) != 0) {
6496: la1tokens[96 + j] = true;
6497: }
6498: if ((jj_la1_4[i] & (1 << j)) != 0) {
6499: la1tokens[128 + j] = true;
6500: }
6501: }
6502: }
6503: }
6504: for (int i = 0; i < 132; i++) {
6505: if (la1tokens[i]) {
6506: jj_expentry = new int[1];
6507: jj_expentry[0] = i;
6508: jj_expentries.addElement(jj_expentry);
6509: }
6510: }
6511: jj_endpos = 0;
6512: jj_rescan_token();
6513: jj_add_error_token(0, 0);
6514: int[][] exptokseq = new int[jj_expentries.size()][];
6515: for (int i = 0; i < jj_expentries.size(); i++) {
6516: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
6517: }
6518: return new ParseException(token, exptokseq, tokenImage);
6519: }
6520:
6521: final public void enable_tracing() {
6522: }
6523:
6524: final public void disable_tracing() {
6525: }
6526:
6527: final private void jj_rescan_token() {
6528: jj_rescan = true;
6529: for (int i = 0; i < 17; i++) {
6530: JJCalls p = jj_2_rtns[i];
6531: do {
6532: if (p.gen > jj_gen) {
6533: jj_la = p.arg;
6534: jj_lastpos = jj_scanpos = p.first;
6535: switch (i) {
6536: case 0:
6537: jj_3_1();
6538: break;
6539: case 1:
6540: jj_3_2();
6541: break;
6542: case 2:
6543: jj_3_3();
6544: break;
6545: case 3:
6546: jj_3_4();
6547: break;
6548: case 4:
6549: jj_3_5();
6550: break;
6551: case 5:
6552: jj_3_6();
6553: break;
6554: case 6:
6555: jj_3_7();
6556: break;
6557: case 7:
6558: jj_3_8();
6559: break;
6560: case 8:
6561: jj_3_9();
6562: break;
6563: case 9:
6564: jj_3_10();
6565: break;
6566: case 10:
6567: jj_3_11();
6568: break;
6569: case 11:
6570: jj_3_12();
6571: break;
6572: case 12:
6573: jj_3_13();
6574: break;
6575: case 13:
6576: jj_3_14();
6577: break;
6578: case 14:
6579: jj_3_15();
6580: break;
6581: case 15:
6582: jj_3_16();
6583: break;
6584: case 16:
6585: jj_3_17();
6586: break;
6587: }
6588: }
6589: p = p.next;
6590: } while (p != null);
6591: }
6592: jj_rescan = false;
6593: }
6594:
6595: final private void jj_save(int index, int xla) {
6596: JJCalls p = jj_2_rtns[index];
6597: while (p.gen > jj_gen) {
6598: if (p.next == null) {
6599: p = p.next = new JJCalls();
6600: break;
6601: }
6602: p = p.next;
6603: }
6604: p.gen = jj_gen + xla - jj_la;
6605: p.first = token;
6606: p.arg = xla;
6607: }
6608:
6609: static final class JJCalls {
6610: int gen;
6611: Token first;
6612: int arg;
6613: JJCalls next;
6614: }
6615:
6616: }
|