0001: /* Generated By:JavaCC: Do not edit this line. XPathParser.java */
0002: package org.apache.commons.jxpath.ri.parser;
0003:
0004: import org.apache.commons.jxpath.ri.Compiler;
0005: import java.util.ArrayList;
0006:
0007: public class XPathParser implements XPathParserConstants {
0008: private Compiler compiler;
0009:
0010: public void setCompiler(Compiler compiler) {
0011: this .compiler = compiler;
0012: }
0013:
0014: private String unescape(String string) {
0015: int index = string.indexOf("'");
0016: while (index != -1) {
0017: string = string.substring(0, index) + "\'"
0018: + string.substring(index + 6);
0019: index = string.indexOf("'");
0020: }
0021: index = string.indexOf(""");
0022: while (index != -1) {
0023: string = string.substring(0, index) + "\""
0024: + string.substring(index + 6);
0025: index = string.indexOf(""");
0026: }
0027: return string;
0028: }
0029:
0030: // Note: XPath does not have reserved words, so we have to include all these terminals
0031: final public String NCName() throws ParseException {
0032: switch (jj_nt.kind) {
0033: case OR:
0034: case AND:
0035: case MOD:
0036: case DIV:
0037: case NCName:
0038: NCName_Without_CoreFunctions();
0039: break;
0040: case NODE:
0041: jj_consume_token(NODE);
0042: break;
0043: case TEXT:
0044: jj_consume_token(TEXT);
0045: break;
0046: case COMMENT:
0047: jj_consume_token(COMMENT);
0048: break;
0049: case PI:
0050: jj_consume_token(PI);
0051: break;
0052: case FUNCTION_LAST:
0053: jj_consume_token(FUNCTION_LAST);
0054: break;
0055: case FUNCTION_POSITION:
0056: jj_consume_token(FUNCTION_POSITION);
0057: break;
0058: case FUNCTION_COUNT:
0059: jj_consume_token(FUNCTION_COUNT);
0060: break;
0061: case FUNCTION_ID:
0062: jj_consume_token(FUNCTION_ID);
0063: break;
0064: case FUNCTION_LOCAL_NAME:
0065: jj_consume_token(FUNCTION_LOCAL_NAME);
0066: break;
0067: case FUNCTION_NAMESPACE_URI:
0068: jj_consume_token(FUNCTION_NAMESPACE_URI);
0069: break;
0070: case FUNCTION_NAME:
0071: jj_consume_token(FUNCTION_NAME);
0072: break;
0073: case FUNCTION_STRING:
0074: jj_consume_token(FUNCTION_STRING);
0075: break;
0076: case FUNCTION_CONCAT:
0077: jj_consume_token(FUNCTION_CONCAT);
0078: break;
0079: case FUNCTION_STARTS_WITH:
0080: jj_consume_token(FUNCTION_STARTS_WITH);
0081: break;
0082: case FUNCTION_CONTAINS:
0083: jj_consume_token(FUNCTION_CONTAINS);
0084: break;
0085: case FUNCTION_SUBSTRING_BEFORE:
0086: jj_consume_token(FUNCTION_SUBSTRING_BEFORE);
0087: break;
0088: case FUNCTION_SUBSTRING_AFTER:
0089: jj_consume_token(FUNCTION_SUBSTRING_AFTER);
0090: break;
0091: case FUNCTION_SUBSTRING:
0092: jj_consume_token(FUNCTION_SUBSTRING);
0093: break;
0094: case FUNCTION_STRING_LENGTH:
0095: jj_consume_token(FUNCTION_STRING_LENGTH);
0096: break;
0097: case FUNCTION_NORMALIZE_SPACE:
0098: jj_consume_token(FUNCTION_NORMALIZE_SPACE);
0099: break;
0100: case FUNCTION_TRANSLATE:
0101: jj_consume_token(FUNCTION_TRANSLATE);
0102: break;
0103: case FUNCTION_BOOLEAN:
0104: jj_consume_token(FUNCTION_BOOLEAN);
0105: break;
0106: case FUNCTION_NOT:
0107: jj_consume_token(FUNCTION_NOT);
0108: break;
0109: case FUNCTION_TRUE:
0110: jj_consume_token(FUNCTION_TRUE);
0111: break;
0112: case FUNCTION_FALSE:
0113: jj_consume_token(FUNCTION_FALSE);
0114: break;
0115: case FUNCTION_NULL:
0116: jj_consume_token(FUNCTION_NULL);
0117: break;
0118: case FUNCTION_LANG:
0119: jj_consume_token(FUNCTION_LANG);
0120: break;
0121: case FUNCTION_NUMBER:
0122: jj_consume_token(FUNCTION_NUMBER);
0123: break;
0124: case FUNCTION_SUM:
0125: jj_consume_token(FUNCTION_SUM);
0126: break;
0127: case FUNCTION_FLOOR:
0128: jj_consume_token(FUNCTION_FLOOR);
0129: break;
0130: case FUNCTION_CEILING:
0131: jj_consume_token(FUNCTION_CEILING);
0132: break;
0133: case FUNCTION_ROUND:
0134: jj_consume_token(FUNCTION_ROUND);
0135: break;
0136: case FUNCTION_KEY:
0137: jj_consume_token(FUNCTION_KEY);
0138: break;
0139: case FUNCTION_FORMAT_NUMBER:
0140: jj_consume_token(FUNCTION_FORMAT_NUMBER);
0141: break;
0142: default:
0143: jj_la1[0] = jj_gen;
0144: jj_consume_token(-1);
0145: throw new ParseException();
0146: }
0147: {
0148: if (true)
0149: return token.image;
0150: }
0151: throw new Error("Missing return statement in function");
0152: }
0153:
0154: final public String NCName_Without_CoreFunctions()
0155: throws ParseException {
0156: switch (jj_nt.kind) {
0157: case NCName:
0158: jj_consume_token(NCName);
0159: break;
0160: case OR:
0161: jj_consume_token(OR);
0162: break;
0163: case AND:
0164: jj_consume_token(AND);
0165: break;
0166: case MOD:
0167: jj_consume_token(MOD);
0168: break;
0169: case DIV:
0170: jj_consume_token(DIV);
0171: break;
0172: default:
0173: jj_la1[1] = jj_gen;
0174: jj_consume_token(-1);
0175: throw new ParseException();
0176: }
0177: {
0178: if (true)
0179: return token.image;
0180: }
0181: throw new Error("Missing return statement in function");
0182: }
0183:
0184: final public int CoreFunctionName() throws ParseException {
0185: int code;
0186: switch (jj_nt.kind) {
0187: case FUNCTION_LAST:
0188: jj_consume_token(FUNCTION_LAST);
0189: code = Compiler.FUNCTION_LAST;
0190: break;
0191: case FUNCTION_POSITION:
0192: jj_consume_token(FUNCTION_POSITION);
0193: code = Compiler.FUNCTION_POSITION;
0194: break;
0195: case FUNCTION_COUNT:
0196: jj_consume_token(FUNCTION_COUNT);
0197: code = Compiler.FUNCTION_COUNT;
0198: break;
0199: case FUNCTION_ID:
0200: jj_consume_token(FUNCTION_ID);
0201: code = Compiler.FUNCTION_ID;
0202: break;
0203: case FUNCTION_LOCAL_NAME:
0204: jj_consume_token(FUNCTION_LOCAL_NAME);
0205: code = Compiler.FUNCTION_LOCAL_NAME;
0206: break;
0207: case FUNCTION_NAMESPACE_URI:
0208: jj_consume_token(FUNCTION_NAMESPACE_URI);
0209: code = Compiler.FUNCTION_NAMESPACE_URI;
0210: break;
0211: case FUNCTION_NAME:
0212: jj_consume_token(FUNCTION_NAME);
0213: code = Compiler.FUNCTION_NAME;
0214: break;
0215: case FUNCTION_STRING:
0216: jj_consume_token(FUNCTION_STRING);
0217: code = Compiler.FUNCTION_STRING;
0218: break;
0219: case FUNCTION_CONCAT:
0220: jj_consume_token(FUNCTION_CONCAT);
0221: code = Compiler.FUNCTION_CONCAT;
0222: break;
0223: case FUNCTION_STARTS_WITH:
0224: jj_consume_token(FUNCTION_STARTS_WITH);
0225: code = Compiler.FUNCTION_STARTS_WITH;
0226: break;
0227: case FUNCTION_CONTAINS:
0228: jj_consume_token(FUNCTION_CONTAINS);
0229: code = Compiler.FUNCTION_CONTAINS;
0230: break;
0231: case FUNCTION_SUBSTRING_BEFORE:
0232: jj_consume_token(FUNCTION_SUBSTRING_BEFORE);
0233: code = Compiler.FUNCTION_SUBSTRING_BEFORE;
0234: break;
0235: case FUNCTION_SUBSTRING_AFTER:
0236: jj_consume_token(FUNCTION_SUBSTRING_AFTER);
0237: code = Compiler.FUNCTION_SUBSTRING_AFTER;
0238: break;
0239: case FUNCTION_SUBSTRING:
0240: jj_consume_token(FUNCTION_SUBSTRING);
0241: code = Compiler.FUNCTION_SUBSTRING;
0242: break;
0243: case FUNCTION_STRING_LENGTH:
0244: jj_consume_token(FUNCTION_STRING_LENGTH);
0245: code = Compiler.FUNCTION_STRING_LENGTH;
0246: break;
0247: case FUNCTION_NORMALIZE_SPACE:
0248: jj_consume_token(FUNCTION_NORMALIZE_SPACE);
0249: code = Compiler.FUNCTION_NORMALIZE_SPACE;
0250: break;
0251: case FUNCTION_TRANSLATE:
0252: jj_consume_token(FUNCTION_TRANSLATE);
0253: code = Compiler.FUNCTION_TRANSLATE;
0254: break;
0255: case FUNCTION_BOOLEAN:
0256: jj_consume_token(FUNCTION_BOOLEAN);
0257: code = Compiler.FUNCTION_BOOLEAN;
0258: break;
0259: case FUNCTION_NOT:
0260: jj_consume_token(FUNCTION_NOT);
0261: code = Compiler.FUNCTION_NOT;
0262: break;
0263: case FUNCTION_TRUE:
0264: jj_consume_token(FUNCTION_TRUE);
0265: code = Compiler.FUNCTION_TRUE;
0266: break;
0267: case FUNCTION_FALSE:
0268: jj_consume_token(FUNCTION_FALSE);
0269: code = Compiler.FUNCTION_FALSE;
0270: break;
0271: case FUNCTION_NULL:
0272: jj_consume_token(FUNCTION_NULL);
0273: code = Compiler.FUNCTION_NULL;
0274: break;
0275: case FUNCTION_LANG:
0276: jj_consume_token(FUNCTION_LANG);
0277: code = Compiler.FUNCTION_LANG;
0278: break;
0279: case FUNCTION_NUMBER:
0280: jj_consume_token(FUNCTION_NUMBER);
0281: code = Compiler.FUNCTION_NUMBER;
0282: break;
0283: case FUNCTION_SUM:
0284: jj_consume_token(FUNCTION_SUM);
0285: code = Compiler.FUNCTION_SUM;
0286: break;
0287: case FUNCTION_FLOOR:
0288: jj_consume_token(FUNCTION_FLOOR);
0289: code = Compiler.FUNCTION_FLOOR;
0290: break;
0291: case FUNCTION_CEILING:
0292: jj_consume_token(FUNCTION_CEILING);
0293: code = Compiler.FUNCTION_CEILING;
0294: break;
0295: case FUNCTION_ROUND:
0296: jj_consume_token(FUNCTION_ROUND);
0297: code = Compiler.FUNCTION_ROUND;
0298: break;
0299: case FUNCTION_KEY:
0300: jj_consume_token(FUNCTION_KEY);
0301: code = Compiler.FUNCTION_KEY;
0302: break;
0303: case FUNCTION_FORMAT_NUMBER:
0304: jj_consume_token(FUNCTION_FORMAT_NUMBER);
0305: code = Compiler.FUNCTION_FORMAT_NUMBER;
0306: break;
0307: default:
0308: jj_la1[2] = jj_gen;
0309: jj_consume_token(-1);
0310: throw new ParseException();
0311: }
0312: {
0313: if (true)
0314: return code;
0315: }
0316: throw new Error("Missing return statement in function");
0317: }
0318:
0319: final public Object QName() throws ParseException {
0320: String nc1, nc2 = null;
0321: nc1 = NCName();
0322: switch (jj_nt.kind) {
0323: case 79:
0324: jj_consume_token(79);
0325: nc2 = NCName();
0326: break;
0327: default:
0328: jj_la1[3] = jj_gen;
0329: ;
0330: }
0331: if (nc2 == null) {
0332: {
0333: if (true)
0334: return compiler.qname(null, nc1);
0335: }
0336: } else {
0337: {
0338: if (true)
0339: return compiler.qname(nc1, nc2);
0340: }
0341: }
0342: throw new Error("Missing return statement in function");
0343: }
0344:
0345: final public Object QName_Without_CoreFunctions()
0346: throws ParseException {
0347: String nc1, nc2 = null;
0348: if (jj_2_1(2147483647)) {
0349: nc1 = NCName();
0350: jj_consume_token(79);
0351: nc2 = NCName();
0352: } else {
0353: switch (jj_nt.kind) {
0354: case OR:
0355: case AND:
0356: case MOD:
0357: case DIV:
0358: case NCName:
0359: nc1 = NCName_Without_CoreFunctions();
0360: break;
0361: default:
0362: jj_la1[4] = jj_gen;
0363: jj_consume_token(-1);
0364: throw new ParseException();
0365: }
0366: }
0367: if (nc2 == null) {
0368: {
0369: if (true)
0370: return compiler.qname(null, nc1);
0371: }
0372: } else {
0373: {
0374: if (true)
0375: return compiler.qname(nc1, nc2);
0376: }
0377: }
0378: throw new Error("Missing return statement in function");
0379: }
0380:
0381: final public Object parseExpression() throws ParseException {
0382: Object ex;
0383: ex = Expression();
0384: jj_consume_token(0);
0385: {
0386: if (true)
0387: return ex;
0388: }
0389: throw new Error("Missing return statement in function");
0390: }
0391:
0392: /* ################################################################################### */
0393: /* XSLT Patterns (http://www.w3.org/1999/08/WD-xslt-19990813) */
0394: /* ################################################################################### */
0395:
0396: /* [XSLT1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern */
0397:
0398: //void Pattern() :
0399: //{}
0400: //{
0401: // LocationPathPattern() ( <UNION> LocationPathPattern() )* <EOF>
0402: //}
0403: //
0404: //
0405: ///* [XSLT2] LocationPathPattern ::=
0406: // '/' RelativePathPattern? | IdKeyPattern (('/' | '//' RelativePathPattern)? | '//'? RelativePathPattern
0407: //*/
0408: //
0409: //void LocationPathPattern() :
0410: //{}
0411: //{
0412: // <SLASH> ( RelativePathPattern() )?
0413: // | (
0414: // LOOKAHEAD(IdKeyPattern())
0415: // IdKeyPattern() ( ( <SLASH> | <SLASHSLASH>) RelativePathPattern() )?
0416: // | ( <SLASHSLASH> )? RelativePathPattern()
0417: // )
0418: //}
0419: //
0420: //
0421: //
0422: ///* [XSLT3] IdKeyPattern ::= 'id' '(' Literal ')' | 'key' '(' Literal ',' Literal ')' */
0423: //
0424: //void IdKeyPattern() :
0425: //{}
0426: //{
0427: // <ID> "(" <Literal> ")"
0428: // | <KEY> "(" <Literal> "," <Literal> ")"
0429: //}
0430: //
0431: //
0432: ///* [XSLT4] RelativePathPattern ::= StepPattern | RelativePathPattern '/' StepPattern
0433: // | RelativePathPattern '//' StepPattern
0434: //*/
0435: //void RelativePathPattern() :
0436: //{}
0437: //{
0438: // StepPattern() ( ( <SLASH>| <SLASHSLASH> ) StepPattern() )*
0439: //}
0440: //
0441: //
0442: ///* [XSLT5] StepPattern ::= AbbreviatedAxisSpecifier NodeTest Predicate* */
0443: //void StepPattern() :
0444: //{}
0445: //{
0446: // AbbreviatedAxisSpecifier() NodeTest() (Predicate())*
0447: //}
0448:
0449: // See XPath Syntax (http://www.w3.org/TR/xpath )
0450:
0451: //void XPath() :
0452: //{}
0453: //{
0454: // LocationPath()
0455: // <EOF>
0456: //}
0457:
0458: /* [1] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath */
0459: final public Object LocationPath() throws ParseException {
0460: Object ex = null;
0461: switch (jj_nt.kind) {
0462: case OR:
0463: case AND:
0464: case MOD:
0465: case DIV:
0466: case NODE:
0467: case TEXT:
0468: case COMMENT:
0469: case PI:
0470: case AXIS_SELF:
0471: case AXIS_CHILD:
0472: case AXIS_PARENT:
0473: case AXIS_ANCESTOR:
0474: case AXIS_ATTRIBUTE:
0475: case AXIS_NAMESPACE:
0476: case AXIS_PRECEDING:
0477: case AXIS_FOLLOWING:
0478: case AXIS_DESCENDANT:
0479: case AXIS_ANCESTOR_OR_SELF:
0480: case AXIS_FOLLOWING_SIBLING:
0481: case AXIS_PRECEDING_SIBLING:
0482: case AXIS_DESCENDANT_OR_SELF:
0483: case FUNCTION_LAST:
0484: case FUNCTION_POSITION:
0485: case FUNCTION_COUNT:
0486: case FUNCTION_ID:
0487: case FUNCTION_KEY:
0488: case FUNCTION_LOCAL_NAME:
0489: case FUNCTION_NAMESPACE_URI:
0490: case FUNCTION_NAME:
0491: case FUNCTION_STRING:
0492: case FUNCTION_CONCAT:
0493: case FUNCTION_STARTS_WITH:
0494: case FUNCTION_CONTAINS:
0495: case FUNCTION_SUBSTRING_BEFORE:
0496: case FUNCTION_SUBSTRING_AFTER:
0497: case FUNCTION_SUBSTRING:
0498: case FUNCTION_STRING_LENGTH:
0499: case FUNCTION_NORMALIZE_SPACE:
0500: case FUNCTION_TRANSLATE:
0501: case FUNCTION_BOOLEAN:
0502: case FUNCTION_NOT:
0503: case FUNCTION_TRUE:
0504: case FUNCTION_FALSE:
0505: case FUNCTION_NULL:
0506: case FUNCTION_LANG:
0507: case FUNCTION_NUMBER:
0508: case FUNCTION_SUM:
0509: case FUNCTION_FLOOR:
0510: case FUNCTION_CEILING:
0511: case FUNCTION_ROUND:
0512: case FUNCTION_FORMAT_NUMBER:
0513: case NCName:
0514: case 82:
0515: case 83:
0516: case 86:
0517: case 88:
0518: ex = RelativeLocationPath();
0519: break;
0520: case SLASH:
0521: case SLASHSLASH:
0522: ex = AbsoluteLocationPath();
0523: break;
0524: default:
0525: jj_la1[5] = jj_gen;
0526: jj_consume_token(-1);
0527: throw new ParseException();
0528: }
0529: {
0530: if (true)
0531: return ex;
0532: }
0533: throw new Error("Missing return statement in function");
0534: }
0535:
0536: /* [2] AbsoluteLocationPath ::= '/' RelativeLocationPath? | AbbreviatedAbsoluteLocationPath */
0537: /* [10] AbbreviatedAbsoluteLocationPath ::= '//' RelativeLocationPath */
0538: final public Object AbsoluteLocationPath() throws ParseException {
0539: ArrayList steps = new ArrayList();
0540: if (jj_2_2(2147483647)) {
0541: LocationStep(steps);
0542: label_1: while (true) {
0543: switch (jj_nt.kind) {
0544: case SLASH:
0545: case SLASHSLASH:
0546: ;
0547: break;
0548: default:
0549: jj_la1[6] = jj_gen;
0550: break label_1;
0551: }
0552: LocationStep(steps);
0553: }
0554: } else {
0555: switch (jj_nt.kind) {
0556: case SLASH:
0557: jj_consume_token(SLASH);
0558: break;
0559: default:
0560: jj_la1[7] = jj_gen;
0561: jj_consume_token(-1);
0562: throw new ParseException();
0563: }
0564: }
0565: {
0566: if (true)
0567: return compiler.locationPath(true, steps.toArray());
0568: }
0569: throw new Error("Missing return statement in function");
0570: }
0571:
0572: /* [3] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | AbbreviatedRelativeLocationPath */
0573: final public Object RelativeLocationPath() throws ParseException {
0574: ArrayList steps = new ArrayList();
0575: NodeTest(steps);
0576: label_2: while (true) {
0577: switch (jj_nt.kind) {
0578: case SLASH:
0579: case SLASHSLASH:
0580: ;
0581: break;
0582: default:
0583: jj_la1[8] = jj_gen;
0584: break label_2;
0585: }
0586: LocationStep(steps);
0587: }
0588: {
0589: if (true)
0590: return compiler.locationPath(false, steps.toArray());
0591: }
0592: throw new Error("Missing return statement in function");
0593: }
0594:
0595: /* [3] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | AbbreviatedRelativeLocationPath */
0596: /* [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step */
0597:
0598: /*--------------------*/
0599: /* 2.1 Location Steps */
0600: /*--------------------*/
0601:
0602: /* [4] Step ::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep */
0603: final public void LocationStep(ArrayList steps)
0604: throws ParseException {
0605: Object t;
0606: Object s;
0607: switch (jj_nt.kind) {
0608: case SLASH:
0609: jj_consume_token(SLASH);
0610: break;
0611: case SLASHSLASH:
0612: jj_consume_token(SLASHSLASH);
0613: // Abbreviated step: descendant-or-self::node()
0614: t = compiler.nodeTypeTest(Compiler.NODE_TYPE_NODE);
0615: steps.add(compiler.step(Compiler.AXIS_DESCENDANT_OR_SELF,
0616: t, null));
0617: break;
0618: default:
0619: jj_la1[9] = jj_gen;
0620: jj_consume_token(-1);
0621: throw new ParseException();
0622: }
0623: NodeTest(steps);
0624: }
0625:
0626: /* [7] NodeTest ::= WildcardName | NodeType '(' ')' | 'processing-instruction' '(' Literal ')' */
0627: final public void NodeTest(ArrayList steps) throws ParseException {
0628: int axis;
0629: int type = -1;
0630: String instruction = null;
0631: Object name = null;
0632: Object s;
0633: Object p;
0634: ArrayList ps = new ArrayList();
0635: switch (jj_nt.kind) {
0636: case OR:
0637: case AND:
0638: case MOD:
0639: case DIV:
0640: case NODE:
0641: case TEXT:
0642: case COMMENT:
0643: case PI:
0644: case AXIS_SELF:
0645: case AXIS_CHILD:
0646: case AXIS_PARENT:
0647: case AXIS_ANCESTOR:
0648: case AXIS_ATTRIBUTE:
0649: case AXIS_NAMESPACE:
0650: case AXIS_PRECEDING:
0651: case AXIS_FOLLOWING:
0652: case AXIS_DESCENDANT:
0653: case AXIS_ANCESTOR_OR_SELF:
0654: case AXIS_FOLLOWING_SIBLING:
0655: case AXIS_PRECEDING_SIBLING:
0656: case AXIS_DESCENDANT_OR_SELF:
0657: case FUNCTION_LAST:
0658: case FUNCTION_POSITION:
0659: case FUNCTION_COUNT:
0660: case FUNCTION_ID:
0661: case FUNCTION_KEY:
0662: case FUNCTION_LOCAL_NAME:
0663: case FUNCTION_NAMESPACE_URI:
0664: case FUNCTION_NAME:
0665: case FUNCTION_STRING:
0666: case FUNCTION_CONCAT:
0667: case FUNCTION_STARTS_WITH:
0668: case FUNCTION_CONTAINS:
0669: case FUNCTION_SUBSTRING_BEFORE:
0670: case FUNCTION_SUBSTRING_AFTER:
0671: case FUNCTION_SUBSTRING:
0672: case FUNCTION_STRING_LENGTH:
0673: case FUNCTION_NORMALIZE_SPACE:
0674: case FUNCTION_TRANSLATE:
0675: case FUNCTION_BOOLEAN:
0676: case FUNCTION_NOT:
0677: case FUNCTION_TRUE:
0678: case FUNCTION_FALSE:
0679: case FUNCTION_NULL:
0680: case FUNCTION_LANG:
0681: case FUNCTION_NUMBER:
0682: case FUNCTION_SUM:
0683: case FUNCTION_FLOOR:
0684: case FUNCTION_CEILING:
0685: case FUNCTION_ROUND:
0686: case FUNCTION_FORMAT_NUMBER:
0687: case NCName:
0688: case 86:
0689: case 88:
0690: axis = AxisSpecifier();
0691: if (jj_2_3(2147483647)) {
0692: type = NodeType();
0693: jj_consume_token(80);
0694: jj_consume_token(81);
0695: } else if (jj_2_4(2147483647)) {
0696: jj_consume_token(PI);
0697: jj_consume_token(80);
0698: jj_consume_token(Literal);
0699: instruction = unescape(token.image.substring(1,
0700: token.image.length() - 1));
0701: jj_consume_token(81);
0702: } else {
0703: switch (jj_nt.kind) {
0704: case OR:
0705: case AND:
0706: case MOD:
0707: case DIV:
0708: case NODE:
0709: case TEXT:
0710: case COMMENT:
0711: case PI:
0712: case FUNCTION_LAST:
0713: case FUNCTION_POSITION:
0714: case FUNCTION_COUNT:
0715: case FUNCTION_ID:
0716: case FUNCTION_KEY:
0717: case FUNCTION_LOCAL_NAME:
0718: case FUNCTION_NAMESPACE_URI:
0719: case FUNCTION_NAME:
0720: case FUNCTION_STRING:
0721: case FUNCTION_CONCAT:
0722: case FUNCTION_STARTS_WITH:
0723: case FUNCTION_CONTAINS:
0724: case FUNCTION_SUBSTRING_BEFORE:
0725: case FUNCTION_SUBSTRING_AFTER:
0726: case FUNCTION_SUBSTRING:
0727: case FUNCTION_STRING_LENGTH:
0728: case FUNCTION_NORMALIZE_SPACE:
0729: case FUNCTION_TRANSLATE:
0730: case FUNCTION_BOOLEAN:
0731: case FUNCTION_NOT:
0732: case FUNCTION_TRUE:
0733: case FUNCTION_FALSE:
0734: case FUNCTION_NULL:
0735: case FUNCTION_LANG:
0736: case FUNCTION_NUMBER:
0737: case FUNCTION_SUM:
0738: case FUNCTION_FLOOR:
0739: case FUNCTION_CEILING:
0740: case FUNCTION_ROUND:
0741: case FUNCTION_FORMAT_NUMBER:
0742: case NCName:
0743: case 88:
0744: name = WildcardName();
0745: break;
0746: default:
0747: jj_la1[10] = jj_gen;
0748: jj_consume_token(-1);
0749: throw new ParseException();
0750: }
0751: }
0752: break;
0753: case 82:
0754: jj_consume_token(82);
0755: axis = Compiler.AXIS_SELF;
0756: type = Compiler.NODE_TYPE_NODE;
0757: break;
0758: case 83:
0759: jj_consume_token(83);
0760: axis = Compiler.AXIS_PARENT;
0761: type = Compiler.NODE_TYPE_NODE;
0762: break;
0763: default:
0764: jj_la1[11] = jj_gen;
0765: jj_consume_token(-1);
0766: throw new ParseException();
0767: }
0768: label_3: while (true) {
0769: switch (jj_nt.kind) {
0770: case 84:
0771: ;
0772: break;
0773: default:
0774: jj_la1[12] = jj_gen;
0775: break label_3;
0776: }
0777: p = Predicate();
0778: ps.add(p);
0779: }
0780: if (name != null) {
0781: s = compiler.nodeNameTest(name);
0782: } else if (instruction != null) {
0783: s = compiler.processingInstructionTest(instruction);
0784: } else {
0785: s = compiler.nodeTypeTest(type);
0786: }
0787: steps.add(compiler.step(axis, s, ps.toArray()));
0788: }
0789:
0790: /* [5] AxisSpecifier ::= AxisName '::' | AbbreviatedAxisSpecifier */
0791: final public int AxisSpecifier() throws ParseException {
0792: int axis;
0793: switch (jj_nt.kind) {
0794: case AXIS_SELF:
0795: case AXIS_CHILD:
0796: case AXIS_PARENT:
0797: case AXIS_ANCESTOR:
0798: case AXIS_ATTRIBUTE:
0799: case AXIS_NAMESPACE:
0800: case AXIS_PRECEDING:
0801: case AXIS_FOLLOWING:
0802: case AXIS_DESCENDANT:
0803: case AXIS_ANCESTOR_OR_SELF:
0804: case AXIS_FOLLOWING_SIBLING:
0805: case AXIS_PRECEDING_SIBLING:
0806: case AXIS_DESCENDANT_OR_SELF:
0807: axis = AxisName();
0808: break;
0809: default:
0810: jj_la1[13] = jj_gen;
0811: axis = AbbreviatedAxisSpecifier();
0812: }
0813: {
0814: if (true)
0815: return axis;
0816: }
0817: throw new Error("Missing return statement in function");
0818: }
0819:
0820: /*----------*/
0821: /* 2.2 Axes */
0822: /*----------*/
0823:
0824: /* [6] AxisName ::= 'ancestor' | 'ancestor-or-self' | 'attribute' | 'child' | 'descendant'
0825: | 'descendant-or-self' | 'following' | 'following-sibling' | 'namespace'
0826: | 'parent' | 'preceding' | 'preceding-sibling' | 'self'
0827: */
0828: final public int AxisName() throws ParseException {
0829: int axis = 0;
0830: switch (jj_nt.kind) {
0831: case AXIS_SELF:
0832: jj_consume_token(AXIS_SELF);
0833: axis = Compiler.AXIS_SELF;
0834: break;
0835: case AXIS_CHILD:
0836: jj_consume_token(AXIS_CHILD);
0837: axis = Compiler.AXIS_CHILD;
0838: break;
0839: case AXIS_PARENT:
0840: jj_consume_token(AXIS_PARENT);
0841: axis = Compiler.AXIS_PARENT;
0842: break;
0843: case AXIS_ANCESTOR:
0844: jj_consume_token(AXIS_ANCESTOR);
0845: axis = Compiler.AXIS_ANCESTOR;
0846: break;
0847: case AXIS_ATTRIBUTE:
0848: jj_consume_token(AXIS_ATTRIBUTE);
0849: axis = Compiler.AXIS_ATTRIBUTE;
0850: break;
0851: case AXIS_NAMESPACE:
0852: jj_consume_token(AXIS_NAMESPACE);
0853: axis = Compiler.AXIS_NAMESPACE;
0854: break;
0855: case AXIS_PRECEDING:
0856: jj_consume_token(AXIS_PRECEDING);
0857: axis = Compiler.AXIS_PRECEDING;
0858: break;
0859: case AXIS_FOLLOWING:
0860: jj_consume_token(AXIS_FOLLOWING);
0861: axis = Compiler.AXIS_FOLLOWING;
0862: break;
0863: case AXIS_DESCENDANT:
0864: jj_consume_token(AXIS_DESCENDANT);
0865: axis = Compiler.AXIS_DESCENDANT;
0866: break;
0867: case AXIS_ANCESTOR_OR_SELF:
0868: jj_consume_token(AXIS_ANCESTOR_OR_SELF);
0869: axis = Compiler.AXIS_ANCESTOR_OR_SELF;
0870: break;
0871: case AXIS_FOLLOWING_SIBLING:
0872: jj_consume_token(AXIS_FOLLOWING_SIBLING);
0873: axis = Compiler.AXIS_FOLLOWING_SIBLING;
0874: break;
0875: case AXIS_PRECEDING_SIBLING:
0876: jj_consume_token(AXIS_PRECEDING_SIBLING);
0877: axis = Compiler.AXIS_PRECEDING_SIBLING;
0878: break;
0879: case AXIS_DESCENDANT_OR_SELF:
0880: jj_consume_token(AXIS_DESCENDANT_OR_SELF);
0881: axis = Compiler.AXIS_DESCENDANT_OR_SELF;
0882: break;
0883: default:
0884: jj_la1[14] = jj_gen;
0885: jj_consume_token(-1);
0886: throw new ParseException();
0887: }
0888: {
0889: if (true)
0890: return axis;
0891: }
0892: throw new Error("Missing return statement in function");
0893: }
0894:
0895: /*----------------*/
0896: /* 2.3 Node Tests */
0897: /*----------------*/
0898:
0899: /*----------------*/
0900: /* 2.4 Predicates */
0901: /*----------------*/
0902:
0903: /* [8] Predicate ::= '[' PredicateExpr ']' */
0904: /* [9] PredicateExpr ::= Expr */
0905: final public Object Predicate() throws ParseException {
0906: Object ex;
0907: jj_consume_token(84);
0908: ex = Expression();
0909: jj_consume_token(85);
0910: {
0911: if (true)
0912: return ex;
0913: }
0914: throw new Error("Missing return statement in function");
0915: }
0916:
0917: /* [12] AbbreviatedStep ::= '.' | '..' */
0918:
0919: /* [13] AbbreviatedAxisSpecifier ::= '@'? */
0920: final public int AbbreviatedAxisSpecifier() throws ParseException {
0921: int axis = Compiler.AXIS_CHILD;
0922: switch (jj_nt.kind) {
0923: case 86:
0924: jj_consume_token(86);
0925: axis = Compiler.AXIS_ATTRIBUTE;
0926: break;
0927: default:
0928: jj_la1[15] = jj_gen;
0929: ;
0930: }
0931: {
0932: if (true)
0933: return axis;
0934: }
0935: throw new Error("Missing return statement in function");
0936: }
0937:
0938: /*---------------*/
0939: /* 3 Expressions */
0940: /*---------------*/
0941:
0942: /*------------*/
0943: /* 3.1 Basics */
0944: /*------------*/
0945:
0946: /*
0947: The effect of the grammar is that the order of precedence is (lowest precedence first):
0948: or
0949: and
0950: =, !=
0951: <=, <, >=, >
0952: and all operators are left associative.
0953: For example, 3 > 2 > 1 is equivalent to (3 > 2) > 1, which evaluates to false.
0954: */
0955:
0956: /* [14] Expr ::= OrExpr */
0957: final public Object Expression() throws ParseException {
0958: Object ex;
0959: ex = OrExpr();
0960: {
0961: if (true)
0962: return ex;
0963: }
0964: throw new Error("Missing return statement in function");
0965: }
0966:
0967: /* [15] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall */
0968: final public Object PrimaryExpr() throws ParseException {
0969: Object ex = null;
0970: switch (jj_nt.kind) {
0971: case VARIABLE:
0972: ex = VariableReference();
0973: break;
0974: case 80:
0975: jj_consume_token(80);
0976: ex = Expression();
0977: jj_consume_token(81);
0978: break;
0979: case Literal:
0980: jj_consume_token(Literal);
0981: ex = compiler.literal(unescape(token.image.substring(1,
0982: token.image.length() - 1)));
0983: break;
0984: case Number:
0985: jj_consume_token(Number);
0986: ex = compiler.number(token.image);
0987: break;
0988: default:
0989: jj_la1[16] = jj_gen;
0990: if (jj_2_5(2147483647)) {
0991: ex = CoreFunctionCall();
0992: } else {
0993: switch (jj_nt.kind) {
0994: case OR:
0995: case AND:
0996: case MOD:
0997: case DIV:
0998: case NODE:
0999: case TEXT:
1000: case COMMENT:
1001: case PI:
1002: case FUNCTION_LAST:
1003: case FUNCTION_POSITION:
1004: case FUNCTION_COUNT:
1005: case FUNCTION_ID:
1006: case FUNCTION_KEY:
1007: case FUNCTION_LOCAL_NAME:
1008: case FUNCTION_NAMESPACE_URI:
1009: case FUNCTION_NAME:
1010: case FUNCTION_STRING:
1011: case FUNCTION_CONCAT:
1012: case FUNCTION_STARTS_WITH:
1013: case FUNCTION_CONTAINS:
1014: case FUNCTION_SUBSTRING_BEFORE:
1015: case FUNCTION_SUBSTRING_AFTER:
1016: case FUNCTION_SUBSTRING:
1017: case FUNCTION_STRING_LENGTH:
1018: case FUNCTION_NORMALIZE_SPACE:
1019: case FUNCTION_TRANSLATE:
1020: case FUNCTION_BOOLEAN:
1021: case FUNCTION_NOT:
1022: case FUNCTION_TRUE:
1023: case FUNCTION_FALSE:
1024: case FUNCTION_NULL:
1025: case FUNCTION_LANG:
1026: case FUNCTION_NUMBER:
1027: case FUNCTION_SUM:
1028: case FUNCTION_FLOOR:
1029: case FUNCTION_CEILING:
1030: case FUNCTION_ROUND:
1031: case FUNCTION_FORMAT_NUMBER:
1032: case NCName:
1033: ex = FunctionCall();
1034: break;
1035: default:
1036: jj_la1[17] = jj_gen;
1037: jj_consume_token(-1);
1038: throw new ParseException();
1039: }
1040: }
1041: }
1042: {
1043: if (true)
1044: return ex;
1045: }
1046: throw new Error("Missing return statement in function");
1047: }
1048:
1049: /*--------------------*/
1050: /* 3.2 Function Calls */
1051: /*--------------------*/
1052:
1053: /* [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')' */
1054: final public Object FunctionCall() throws ParseException {
1055: Object name;
1056: ArrayList args;
1057: name = FunctionName();
1058: args = ArgumentList();
1059: if (args == null) {
1060: {
1061: if (true)
1062: return compiler.function(name, null);
1063: }
1064: } else {
1065: {
1066: if (true)
1067: return compiler.function(name, args.toArray());
1068: }
1069: }
1070: throw new Error("Missing return statement in function");
1071: }
1072:
1073: final public Object CoreFunctionCall() throws ParseException {
1074: int code = 0;
1075: ArrayList args;
1076: code = CoreFunctionName();
1077: args = ArgumentList();
1078: if (args == null) {
1079: {
1080: if (true)
1081: return compiler.function(code, null);
1082: }
1083: } else {
1084: {
1085: if (true)
1086: return compiler.function(code, args.toArray());
1087: }
1088: }
1089: throw new Error("Missing return statement in function");
1090: }
1091:
1092: final public ArrayList ArgumentList() throws ParseException {
1093: ArrayList args = null;
1094: Object arg;
1095: jj_consume_token(80);
1096: switch (jj_nt.kind) {
1097: case SLASH:
1098: case SLASHSLASH:
1099: case MINUS:
1100: case VARIABLE:
1101: case Literal:
1102: case Number:
1103: case OR:
1104: case AND:
1105: case MOD:
1106: case DIV:
1107: case NODE:
1108: case TEXT:
1109: case COMMENT:
1110: case PI:
1111: case AXIS_SELF:
1112: case AXIS_CHILD:
1113: case AXIS_PARENT:
1114: case AXIS_ANCESTOR:
1115: case AXIS_ATTRIBUTE:
1116: case AXIS_NAMESPACE:
1117: case AXIS_PRECEDING:
1118: case AXIS_FOLLOWING:
1119: case AXIS_DESCENDANT:
1120: case AXIS_ANCESTOR_OR_SELF:
1121: case AXIS_FOLLOWING_SIBLING:
1122: case AXIS_PRECEDING_SIBLING:
1123: case AXIS_DESCENDANT_OR_SELF:
1124: case FUNCTION_LAST:
1125: case FUNCTION_POSITION:
1126: case FUNCTION_COUNT:
1127: case FUNCTION_ID:
1128: case FUNCTION_KEY:
1129: case FUNCTION_LOCAL_NAME:
1130: case FUNCTION_NAMESPACE_URI:
1131: case FUNCTION_NAME:
1132: case FUNCTION_STRING:
1133: case FUNCTION_CONCAT:
1134: case FUNCTION_STARTS_WITH:
1135: case FUNCTION_CONTAINS:
1136: case FUNCTION_SUBSTRING_BEFORE:
1137: case FUNCTION_SUBSTRING_AFTER:
1138: case FUNCTION_SUBSTRING:
1139: case FUNCTION_STRING_LENGTH:
1140: case FUNCTION_NORMALIZE_SPACE:
1141: case FUNCTION_TRANSLATE:
1142: case FUNCTION_BOOLEAN:
1143: case FUNCTION_NOT:
1144: case FUNCTION_TRUE:
1145: case FUNCTION_FALSE:
1146: case FUNCTION_NULL:
1147: case FUNCTION_LANG:
1148: case FUNCTION_NUMBER:
1149: case FUNCTION_SUM:
1150: case FUNCTION_FLOOR:
1151: case FUNCTION_CEILING:
1152: case FUNCTION_ROUND:
1153: case FUNCTION_FORMAT_NUMBER:
1154: case NCName:
1155: case 80:
1156: case 82:
1157: case 83:
1158: case 86:
1159: case 88:
1160: arg = Argument();
1161: args = new ArrayList();
1162: args.add(arg);
1163: label_4: while (true) {
1164: switch (jj_nt.kind) {
1165: case 87:
1166: ;
1167: break;
1168: default:
1169: jj_la1[18] = jj_gen;
1170: break label_4;
1171: }
1172: jj_consume_token(87);
1173: arg = Argument();
1174: args.add(arg);
1175: }
1176: break;
1177: default:
1178: jj_la1[19] = jj_gen;
1179: ;
1180: }
1181: jj_consume_token(81);
1182: {
1183: if (true)
1184: return args;
1185: }
1186: throw new Error("Missing return statement in function");
1187: }
1188:
1189: /* [17] Argument ::= Expr */
1190: final public Object Argument() throws ParseException {
1191: Object ex;
1192: ex = Expression();
1193: {
1194: if (true)
1195: return ex;
1196: }
1197: throw new Error("Missing return statement in function");
1198: }
1199:
1200: /*---------------*/
1201: /* 3.3 Node-sets */
1202: /*---------------*/
1203:
1204: /* [18] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr */
1205: final public Object UnionExpr() throws ParseException {
1206: Object ex, r;
1207: ArrayList list = null;
1208: ex = PathExpr();
1209: label_5: while (true) {
1210: switch (jj_nt.kind) {
1211: case UNION:
1212: ;
1213: break;
1214: default:
1215: jj_la1[20] = jj_gen;
1216: break label_5;
1217: }
1218: jj_consume_token(UNION);
1219: r = PathExpr();
1220: if (list == null) {
1221: list = new ArrayList();
1222: list.add(ex);
1223: }
1224: list.add(r);
1225: }
1226: if (list != null) {
1227: ex = compiler.union(list.toArray());
1228: }
1229: {
1230: if (true)
1231: return ex;
1232: }
1233: throw new Error("Missing return statement in function");
1234: }
1235:
1236: /* [19] PathExpr ::= LocationPath | FilterExpr | FilterExpr '/' RelativeLocationPath | FilterExpr '//' RelativeLocationPath */
1237: final public Object PathExpr() throws ParseException {
1238: Object ex = null;
1239: Object[] steps;
1240: if (jj_2_6(2147483647)) {
1241: ex = FilterExpr();
1242: } else {
1243: switch (jj_nt.kind) {
1244: case SLASH:
1245: case SLASHSLASH:
1246: case OR:
1247: case AND:
1248: case MOD:
1249: case DIV:
1250: case NODE:
1251: case TEXT:
1252: case COMMENT:
1253: case PI:
1254: case AXIS_SELF:
1255: case AXIS_CHILD:
1256: case AXIS_PARENT:
1257: case AXIS_ANCESTOR:
1258: case AXIS_ATTRIBUTE:
1259: case AXIS_NAMESPACE:
1260: case AXIS_PRECEDING:
1261: case AXIS_FOLLOWING:
1262: case AXIS_DESCENDANT:
1263: case AXIS_ANCESTOR_OR_SELF:
1264: case AXIS_FOLLOWING_SIBLING:
1265: case AXIS_PRECEDING_SIBLING:
1266: case AXIS_DESCENDANT_OR_SELF:
1267: case FUNCTION_LAST:
1268: case FUNCTION_POSITION:
1269: case FUNCTION_COUNT:
1270: case FUNCTION_ID:
1271: case FUNCTION_KEY:
1272: case FUNCTION_LOCAL_NAME:
1273: case FUNCTION_NAMESPACE_URI:
1274: case FUNCTION_NAME:
1275: case FUNCTION_STRING:
1276: case FUNCTION_CONCAT:
1277: case FUNCTION_STARTS_WITH:
1278: case FUNCTION_CONTAINS:
1279: case FUNCTION_SUBSTRING_BEFORE:
1280: case FUNCTION_SUBSTRING_AFTER:
1281: case FUNCTION_SUBSTRING:
1282: case FUNCTION_STRING_LENGTH:
1283: case FUNCTION_NORMALIZE_SPACE:
1284: case FUNCTION_TRANSLATE:
1285: case FUNCTION_BOOLEAN:
1286: case FUNCTION_NOT:
1287: case FUNCTION_TRUE:
1288: case FUNCTION_FALSE:
1289: case FUNCTION_NULL:
1290: case FUNCTION_LANG:
1291: case FUNCTION_NUMBER:
1292: case FUNCTION_SUM:
1293: case FUNCTION_FLOOR:
1294: case FUNCTION_CEILING:
1295: case FUNCTION_ROUND:
1296: case FUNCTION_FORMAT_NUMBER:
1297: case NCName:
1298: case 82:
1299: case 83:
1300: case 86:
1301: case 88:
1302: ex = LocationPath();
1303: break;
1304: default:
1305: jj_la1[21] = jj_gen;
1306: jj_consume_token(-1);
1307: throw new ParseException();
1308: }
1309: }
1310: {
1311: if (true)
1312: return ex;
1313: }
1314: throw new Error("Missing return statement in function");
1315: }
1316:
1317: /* [20] FilterExpr ::= PrimaryExpr | FilterExpr Predicate */
1318: final public Object FilterExpr() throws ParseException {
1319: Object ex, p;
1320: ArrayList ps = new ArrayList();
1321: boolean path = false;
1322: ArrayList steps = new ArrayList();
1323: ex = PrimaryExpr();
1324: label_6: while (true) {
1325: switch (jj_nt.kind) {
1326: case 84:
1327: ;
1328: break;
1329: default:
1330: jj_la1[22] = jj_gen;
1331: break label_6;
1332: }
1333: p = Predicate();
1334: path = true;
1335: ps.add(p);
1336: }
1337: label_7: while (true) {
1338: switch (jj_nt.kind) {
1339: case SLASH:
1340: case SLASHSLASH:
1341: ;
1342: break;
1343: default:
1344: jj_la1[23] = jj_gen;
1345: break label_7;
1346: }
1347: LocationStep(steps);
1348: path = true;
1349: }
1350: if (path) {
1351: {
1352: if (true)
1353: return compiler.expressionPath(ex, ps.toArray(),
1354: steps.toArray());
1355: }
1356: } else {
1357: {
1358: if (true)
1359: return ex;
1360: }
1361: }
1362: throw new Error("Missing return statement in function");
1363: }
1364:
1365: /*--------------*/
1366: /* 3.4 Booleans */
1367: /*--------------*/
1368:
1369: /* [21] OrExpr ::= AndExpr | OrExpr 'or' AndExpr */
1370: final public Object OrExpr() throws ParseException {
1371: Object ex, r;
1372: ArrayList list = null;
1373: ex = AndExpr();
1374: label_8: while (true) {
1375: switch (jj_nt.kind) {
1376: case OR:
1377: ;
1378: break;
1379: default:
1380: jj_la1[24] = jj_gen;
1381: break label_8;
1382: }
1383: jj_consume_token(OR);
1384: r = AndExpr();
1385: if (list == null) {
1386: list = new ArrayList();
1387: list.add(ex);
1388: }
1389: list.add(r);
1390: }
1391: if (list != null) {
1392: ex = compiler.or(list.toArray());
1393: }
1394: {
1395: if (true)
1396: return ex;
1397: }
1398: throw new Error("Missing return statement in function");
1399: }
1400:
1401: /* [22] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr */
1402: final public Object AndExpr() throws ParseException {
1403: Object ex, r;
1404: ArrayList list = null;
1405: ex = EqualityExpr();
1406: label_9: while (true) {
1407: switch (jj_nt.kind) {
1408: case AND:
1409: ;
1410: break;
1411: default:
1412: jj_la1[25] = jj_gen;
1413: break label_9;
1414: }
1415: jj_consume_token(AND);
1416: r = EqualityExpr();
1417: if (list == null) {
1418: list = new ArrayList();
1419: list.add(ex);
1420: }
1421: list.add(r);
1422: }
1423: if (list != null) {
1424: ex = compiler.and(list.toArray());
1425: }
1426: {
1427: if (true)
1428: return ex;
1429: }
1430: throw new Error("Missing return statement in function");
1431: }
1432:
1433: /* [23] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr | EqualityExpr '!=' RelationalExpr */
1434: final public Object EqualityExpr() throws ParseException {
1435: Object ex, r;
1436: ex = RelationalExpr();
1437: label_10: while (true) {
1438: switch (jj_nt.kind) {
1439: case EQ:
1440: case NEQ:
1441: ;
1442: break;
1443: default:
1444: jj_la1[26] = jj_gen;
1445: break label_10;
1446: }
1447: switch (jj_nt.kind) {
1448: case EQ:
1449: jj_consume_token(EQ);
1450: r = RelationalExpr();
1451: ex = compiler.equal(ex, r);
1452: break;
1453: case NEQ:
1454: jj_consume_token(NEQ);
1455: r = RelationalExpr();
1456: ex = compiler.notEqual(ex, r);
1457: break;
1458: default:
1459: jj_la1[27] = jj_gen;
1460: jj_consume_token(-1);
1461: throw new ParseException();
1462: }
1463: }
1464: {
1465: if (true)
1466: return ex;
1467: }
1468: throw new Error("Missing return statement in function");
1469: }
1470:
1471: /* [24] RelationalExpr ::= AdditiveExpr | RelationalExpr '<' AdditiveExpr | RelationalExpr '>' AdditiveExpr
1472: | RelationalExpr '<=' AdditiveExpr | RelationalExpr '>=' AdditiveExpr */
1473: final public Object RelationalExpr() throws ParseException {
1474: Object ex, r;
1475: ex = AdditiveExpr();
1476: label_11: while (true) {
1477: switch (jj_nt.kind) {
1478: case LT:
1479: case LTE:
1480: case GT:
1481: case GTE:
1482: ;
1483: break;
1484: default:
1485: jj_la1[28] = jj_gen;
1486: break label_11;
1487: }
1488: switch (jj_nt.kind) {
1489: case LT:
1490: jj_consume_token(LT);
1491: r = AdditiveExpr();
1492: ex = compiler.lessThan(ex, r);
1493: break;
1494: case GT:
1495: jj_consume_token(GT);
1496: r = AdditiveExpr();
1497: ex = compiler.greaterThan(ex, r);
1498: break;
1499: case LTE:
1500: jj_consume_token(LTE);
1501: r = AdditiveExpr();
1502: ex = compiler.lessThanOrEqual(ex, r);
1503: break;
1504: case GTE:
1505: jj_consume_token(GTE);
1506: r = AdditiveExpr();
1507: ex = compiler.greaterThanOrEqual(ex, r);
1508: break;
1509: default:
1510: jj_la1[29] = jj_gen;
1511: jj_consume_token(-1);
1512: throw new ParseException();
1513: }
1514: }
1515: {
1516: if (true)
1517: return ex;
1518: }
1519: throw new Error("Missing return statement in function");
1520: }
1521:
1522: /*-------------*/
1523: /* 3.5 Numbers */
1524: /*-------------*/
1525:
1526: /* [25] AdditiveExpr ::= MultiplicativeExpr | AdditiveExpr '+' MultiplicativeExpr | AdditiveExpr '-' MultiplicativeExpr */
1527: final public Object AdditiveExpr() throws ParseException {
1528: Object ex, r;
1529: ArrayList list = null;
1530: ex = SubtractiveExpr();
1531: label_12: while (true) {
1532: switch (jj_nt.kind) {
1533: case PLUS:
1534: ;
1535: break;
1536: default:
1537: jj_la1[30] = jj_gen;
1538: break label_12;
1539: }
1540: jj_consume_token(PLUS);
1541: r = SubtractiveExpr();
1542: if (list == null) {
1543: list = new ArrayList();
1544: list.add(ex);
1545: }
1546: list.add(r);
1547: }
1548: if (list != null) {
1549: ex = compiler.sum(list.toArray());
1550: }
1551: {
1552: if (true)
1553: return ex;
1554: }
1555: throw new Error("Missing return statement in function");
1556: }
1557:
1558: final public Object SubtractiveExpr() throws ParseException {
1559: Object ex, r = null;
1560: ex = MultiplicativeExpr();
1561: label_13: while (true) {
1562: switch (jj_nt.kind) {
1563: case MINUS:
1564: ;
1565: break;
1566: default:
1567: jj_la1[31] = jj_gen;
1568: break label_13;
1569: }
1570: jj_consume_token(MINUS);
1571: r = MultiplicativeExpr();
1572: ex = compiler.minus(ex, r);
1573: }
1574: {
1575: if (true)
1576: return ex;
1577: }
1578: throw new Error("Missing return statement in function");
1579: }
1580:
1581: /* [26] MultiplicativeExpr ::= UnaryExpr | MultiplicativeExpr MultiplyOperator UnaryExpr
1582: | MultiplicativeExpr 'div' UnaryExpr | MultiplicativeExpr 'mod' UnaryExpr */
1583: final public Object MultiplicativeExpr() throws ParseException {
1584: Object ex, r;
1585: ex = UnaryExpr();
1586: label_14: while (true) {
1587: switch (jj_nt.kind) {
1588: case MOD:
1589: case DIV:
1590: case 88:
1591: ;
1592: break;
1593: default:
1594: jj_la1[32] = jj_gen;
1595: break label_14;
1596: }
1597: switch (jj_nt.kind) {
1598: case 88:
1599: jj_consume_token(88);
1600: r = UnaryExpr();
1601: ex = compiler.multiply(ex, r);
1602: break;
1603: case DIV:
1604: jj_consume_token(DIV);
1605: r = UnaryExpr();
1606: ex = compiler.divide(ex, r);
1607: break;
1608: case MOD:
1609: jj_consume_token(MOD);
1610: r = UnaryExpr();
1611: ex = compiler.mod(ex, r);
1612: break;
1613: default:
1614: jj_la1[33] = jj_gen;
1615: jj_consume_token(-1);
1616: throw new ParseException();
1617: }
1618: }
1619: {
1620: if (true)
1621: return ex;
1622: }
1623: throw new Error("Missing return statement in function");
1624: }
1625:
1626: /* [27] UnaryExpr ::= UnionExpr | '-' UnaryExpr */
1627: final public Object UnaryExpr() throws ParseException {
1628: Object ex;
1629: switch (jj_nt.kind) {
1630: case SLASH:
1631: case SLASHSLASH:
1632: case VARIABLE:
1633: case Literal:
1634: case Number:
1635: case OR:
1636: case AND:
1637: case MOD:
1638: case DIV:
1639: case NODE:
1640: case TEXT:
1641: case COMMENT:
1642: case PI:
1643: case AXIS_SELF:
1644: case AXIS_CHILD:
1645: case AXIS_PARENT:
1646: case AXIS_ANCESTOR:
1647: case AXIS_ATTRIBUTE:
1648: case AXIS_NAMESPACE:
1649: case AXIS_PRECEDING:
1650: case AXIS_FOLLOWING:
1651: case AXIS_DESCENDANT:
1652: case AXIS_ANCESTOR_OR_SELF:
1653: case AXIS_FOLLOWING_SIBLING:
1654: case AXIS_PRECEDING_SIBLING:
1655: case AXIS_DESCENDANT_OR_SELF:
1656: case FUNCTION_LAST:
1657: case FUNCTION_POSITION:
1658: case FUNCTION_COUNT:
1659: case FUNCTION_ID:
1660: case FUNCTION_KEY:
1661: case FUNCTION_LOCAL_NAME:
1662: case FUNCTION_NAMESPACE_URI:
1663: case FUNCTION_NAME:
1664: case FUNCTION_STRING:
1665: case FUNCTION_CONCAT:
1666: case FUNCTION_STARTS_WITH:
1667: case FUNCTION_CONTAINS:
1668: case FUNCTION_SUBSTRING_BEFORE:
1669: case FUNCTION_SUBSTRING_AFTER:
1670: case FUNCTION_SUBSTRING:
1671: case FUNCTION_STRING_LENGTH:
1672: case FUNCTION_NORMALIZE_SPACE:
1673: case FUNCTION_TRANSLATE:
1674: case FUNCTION_BOOLEAN:
1675: case FUNCTION_NOT:
1676: case FUNCTION_TRUE:
1677: case FUNCTION_FALSE:
1678: case FUNCTION_NULL:
1679: case FUNCTION_LANG:
1680: case FUNCTION_NUMBER:
1681: case FUNCTION_SUM:
1682: case FUNCTION_FLOOR:
1683: case FUNCTION_CEILING:
1684: case FUNCTION_ROUND:
1685: case FUNCTION_FORMAT_NUMBER:
1686: case NCName:
1687: case 80:
1688: case 82:
1689: case 83:
1690: case 86:
1691: case 88:
1692: ex = UnionExpr();
1693: break;
1694: case MINUS:
1695: jj_consume_token(MINUS);
1696: ex = UnaryExpr();
1697: ex = compiler.minus(ex);
1698: break;
1699: default:
1700: jj_la1[34] = jj_gen;
1701: jj_consume_token(-1);
1702: throw new ParseException();
1703: }
1704: {
1705: if (true)
1706: return ex;
1707: }
1708: throw new Error("Missing return statement in function");
1709: }
1710:
1711: /*-------------*/
1712: /* 3.6 Strings */
1713: /*-------------*/
1714:
1715: /*----------------------------------*/
1716: /* 3.7 Expression Lexical Structure */
1717: /*----------------------------------*/
1718: /*
1719: The following special tokenization rules must be applied in the order
1720: specified to disambiguate the grammar:
1721:
1722: 1. If there is a preceding token and the preceding token is not one of
1723: @, ::, (, [, , or an Operator,
1724: then a * must be recognized as a MultiplyOperator and an NCName must
1725: be recognized as an OperatorName.
1726:
1727: 2. If the character following an NCName (possibly after intervening ExprWhitespace)
1728: is (, then the token must be recognized as a NodeType or a FunctionName.
1729:
1730: 3. If the two characters following an NCName (possibly after intervening ExprWhitespace)
1731: are ::, then the token must be recognized as an AxisName.
1732:
1733: 4. Otherwise, the token must not be recognized as a MultiplyOperator, an OperatorName,
1734: a NodeType, a FunctionName, or an AxisName.
1735: */
1736:
1737: /*
1738: [28] ExprToken ::= '(' | ')' | '[' | ']' | '.' | '..' | '@' | ',' | '::'
1739: | WildcardName | NodeType | Operator | FunctionName | AxisName | Literal
1740: | Number | VariableReference
1741: */
1742: /* [34] MultiplyOperator ::= '*' */
1743:
1744: /* [35] FunctionName ::= QName - NodeType */
1745: final public Object FunctionName() throws ParseException {
1746: Object qname;
1747: qname = QName_Without_CoreFunctions();
1748: {
1749: if (true)
1750: return qname;
1751: }
1752: throw new Error("Missing return statement in function");
1753: }
1754:
1755: /* [36] VariableReference ::= '$' QName */
1756: final public Object VariableReference() throws ParseException {
1757: Object ex;
1758: jj_consume_token(VARIABLE);
1759: ex = QName();
1760: {
1761: if (true)
1762: return compiler.variableReference(ex);
1763: }
1764: throw new Error("Missing return statement in function");
1765: }
1766:
1767: /* [37] WildcardName ::= '*' | NCName ':' '*' | QName */
1768: final public Object WildcardName() throws ParseException {
1769: Object qn;
1770: String nc1, nc2 = null;
1771: switch (jj_nt.kind) {
1772: case 88:
1773: jj_consume_token(88);
1774: break;
1775: case OR:
1776: case AND:
1777: case MOD:
1778: case DIV:
1779: case NODE:
1780: case TEXT:
1781: case COMMENT:
1782: case PI:
1783: case FUNCTION_LAST:
1784: case FUNCTION_POSITION:
1785: case FUNCTION_COUNT:
1786: case FUNCTION_ID:
1787: case FUNCTION_KEY:
1788: case FUNCTION_LOCAL_NAME:
1789: case FUNCTION_NAMESPACE_URI:
1790: case FUNCTION_NAME:
1791: case FUNCTION_STRING:
1792: case FUNCTION_CONCAT:
1793: case FUNCTION_STARTS_WITH:
1794: case FUNCTION_CONTAINS:
1795: case FUNCTION_SUBSTRING_BEFORE:
1796: case FUNCTION_SUBSTRING_AFTER:
1797: case FUNCTION_SUBSTRING:
1798: case FUNCTION_STRING_LENGTH:
1799: case FUNCTION_NORMALIZE_SPACE:
1800: case FUNCTION_TRANSLATE:
1801: case FUNCTION_BOOLEAN:
1802: case FUNCTION_NOT:
1803: case FUNCTION_TRUE:
1804: case FUNCTION_FALSE:
1805: case FUNCTION_NULL:
1806: case FUNCTION_LANG:
1807: case FUNCTION_NUMBER:
1808: case FUNCTION_SUM:
1809: case FUNCTION_FLOOR:
1810: case FUNCTION_CEILING:
1811: case FUNCTION_ROUND:
1812: case FUNCTION_FORMAT_NUMBER:
1813: case NCName:
1814: NCName();
1815: break;
1816: default:
1817: jj_la1[35] = jj_gen;
1818: jj_consume_token(-1);
1819: throw new ParseException();
1820: }
1821: nc1 = token.image;
1822: switch (jj_nt.kind) {
1823: case 79:
1824: jj_consume_token(79);
1825: switch (jj_nt.kind) {
1826: case 88:
1827: jj_consume_token(88);
1828: break;
1829: case OR:
1830: case AND:
1831: case MOD:
1832: case DIV:
1833: case NODE:
1834: case TEXT:
1835: case COMMENT:
1836: case PI:
1837: case FUNCTION_LAST:
1838: case FUNCTION_POSITION:
1839: case FUNCTION_COUNT:
1840: case FUNCTION_ID:
1841: case FUNCTION_KEY:
1842: case FUNCTION_LOCAL_NAME:
1843: case FUNCTION_NAMESPACE_URI:
1844: case FUNCTION_NAME:
1845: case FUNCTION_STRING:
1846: case FUNCTION_CONCAT:
1847: case FUNCTION_STARTS_WITH:
1848: case FUNCTION_CONTAINS:
1849: case FUNCTION_SUBSTRING_BEFORE:
1850: case FUNCTION_SUBSTRING_AFTER:
1851: case FUNCTION_SUBSTRING:
1852: case FUNCTION_STRING_LENGTH:
1853: case FUNCTION_NORMALIZE_SPACE:
1854: case FUNCTION_TRANSLATE:
1855: case FUNCTION_BOOLEAN:
1856: case FUNCTION_NOT:
1857: case FUNCTION_TRUE:
1858: case FUNCTION_FALSE:
1859: case FUNCTION_NULL:
1860: case FUNCTION_LANG:
1861: case FUNCTION_NUMBER:
1862: case FUNCTION_SUM:
1863: case FUNCTION_FLOOR:
1864: case FUNCTION_CEILING:
1865: case FUNCTION_ROUND:
1866: case FUNCTION_FORMAT_NUMBER:
1867: case NCName:
1868: NCName();
1869: break;
1870: default:
1871: jj_la1[36] = jj_gen;
1872: jj_consume_token(-1);
1873: throw new ParseException();
1874: }
1875: nc2 = token.image;
1876: break;
1877: default:
1878: jj_la1[37] = jj_gen;
1879: ;
1880: }
1881: if (nc2 != null) {
1882: qn = compiler.qname(nc1, nc2);
1883: } else {
1884: qn = compiler.qname(null, nc1);
1885: }
1886: {
1887: if (true)
1888: return qn;
1889: }
1890: throw new Error("Missing return statement in function");
1891: }
1892:
1893: /* [38] NodeType ::= 'comment' | 'text' | 'processing-instruction' | 'node' */
1894: final public int NodeType() throws ParseException {
1895: int type;
1896: switch (jj_nt.kind) {
1897: case TEXT:
1898: jj_consume_token(TEXT);
1899: type = Compiler.NODE_TYPE_TEXT;
1900: break;
1901: case NODE:
1902: jj_consume_token(NODE);
1903: type = Compiler.NODE_TYPE_NODE;
1904: break;
1905: case COMMENT:
1906: jj_consume_token(COMMENT);
1907: type = Compiler.NODE_TYPE_COMMENT;
1908: break;
1909: case PI:
1910: jj_consume_token(PI);
1911: type = Compiler.NODE_TYPE_PI;
1912: break;
1913: default:
1914: jj_la1[38] = jj_gen;
1915: jj_consume_token(-1);
1916: throw new ParseException();
1917: }
1918: {
1919: if (true)
1920: return type;
1921: }
1922: throw new Error("Missing return statement in function");
1923: }
1924:
1925: final private boolean jj_2_1(int xla) {
1926: jj_la = xla;
1927: jj_lastpos = jj_scanpos = token;
1928: boolean retval = !jj_3_1();
1929: jj_save(0, xla);
1930: return retval;
1931: }
1932:
1933: final private boolean jj_2_2(int xla) {
1934: jj_la = xla;
1935: jj_lastpos = jj_scanpos = token;
1936: boolean retval = !jj_3_2();
1937: jj_save(1, xla);
1938: return retval;
1939: }
1940:
1941: final private boolean jj_2_3(int xla) {
1942: jj_la = xla;
1943: jj_lastpos = jj_scanpos = token;
1944: boolean retval = !jj_3_3();
1945: jj_save(2, xla);
1946: return retval;
1947: }
1948:
1949: final private boolean jj_2_4(int xla) {
1950: jj_la = xla;
1951: jj_lastpos = jj_scanpos = token;
1952: boolean retval = !jj_3_4();
1953: jj_save(3, xla);
1954: return retval;
1955: }
1956:
1957: final private boolean jj_2_5(int xla) {
1958: jj_la = xla;
1959: jj_lastpos = jj_scanpos = token;
1960: boolean retval = !jj_3_5();
1961: jj_save(4, xla);
1962: return retval;
1963: }
1964:
1965: final private boolean jj_2_6(int xla) {
1966: jj_la = xla;
1967: jj_lastpos = jj_scanpos = token;
1968: boolean retval = !jj_3_6();
1969: jj_save(5, xla);
1970: return retval;
1971: }
1972:
1973: final private boolean jj_3R_65() {
1974: if (jj_scan_token(FUNCTION_ID))
1975: return true;
1976: if (jj_la == 0 && jj_scanpos == jj_lastpos)
1977: return false;
1978: return false;
1979: }
1980:
1981: final private boolean jj_3R_104() {
1982: if (jj_3R_118())
1983: return true;
1984: if (jj_la == 0 && jj_scanpos == jj_lastpos)
1985: return false;
1986: return false;
1987: }
1988:
1989: final private boolean jj_3R_64() {
1990: if (jj_scan_token(FUNCTION_COUNT))
1991: return true;
1992: if (jj_la == 0 && jj_scanpos == jj_lastpos)
1993: return false;
1994: return false;
1995: }
1996:
1997: final private boolean jj_3R_63() {
1998: if (jj_scan_token(FUNCTION_POSITION))
1999: return true;
2000: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2001: return false;
2002: return false;
2003: }
2004:
2005: final private boolean jj_3R_62() {
2006: if (jj_scan_token(FUNCTION_LAST))
2007: return true;
2008: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2009: return false;
2010: return false;
2011: }
2012:
2013: final private boolean jj_3R_18() {
2014: Token xsp;
2015: xsp = jj_scanpos;
2016: if (jj_3R_62()) {
2017: jj_scanpos = xsp;
2018: if (jj_3R_63()) {
2019: jj_scanpos = xsp;
2020: if (jj_3R_64()) {
2021: jj_scanpos = xsp;
2022: if (jj_3R_65()) {
2023: jj_scanpos = xsp;
2024: if (jj_3R_66()) {
2025: jj_scanpos = xsp;
2026: if (jj_3R_67()) {
2027: jj_scanpos = xsp;
2028: if (jj_3R_68()) {
2029: jj_scanpos = xsp;
2030: if (jj_3R_69()) {
2031: jj_scanpos = xsp;
2032: if (jj_3R_70()) {
2033: jj_scanpos = xsp;
2034: if (jj_3R_71()) {
2035: jj_scanpos = xsp;
2036: if (jj_3R_72()) {
2037: jj_scanpos = xsp;
2038: if (jj_3R_73()) {
2039: jj_scanpos = xsp;
2040: if (jj_3R_74()) {
2041: jj_scanpos = xsp;
2042: if (jj_3R_75()) {
2043: jj_scanpos = xsp;
2044: if (jj_3R_76()) {
2045: jj_scanpos = xsp;
2046: if (jj_3R_77()) {
2047: jj_scanpos = xsp;
2048: if (jj_3R_78()) {
2049: jj_scanpos = xsp;
2050: if (jj_3R_79()) {
2051: jj_scanpos = xsp;
2052: if (jj_3R_80()) {
2053: jj_scanpos = xsp;
2054: if (jj_3R_81()) {
2055: jj_scanpos = xsp;
2056: if (jj_3R_82()) {
2057: jj_scanpos = xsp;
2058: if (jj_3R_83()) {
2059: jj_scanpos = xsp;
2060: if (jj_3R_84()) {
2061: jj_scanpos = xsp;
2062: if (jj_3R_85()) {
2063: jj_scanpos = xsp;
2064: if (jj_3R_86()) {
2065: jj_scanpos = xsp;
2066: if (jj_3R_87()) {
2067: jj_scanpos = xsp;
2068: if (jj_3R_88()) {
2069: jj_scanpos = xsp;
2070: if (jj_3R_89()) {
2071: jj_scanpos = xsp;
2072: if (jj_3R_90()) {
2073: jj_scanpos = xsp;
2074: if (jj_3R_91())
2075: return true;
2076: if (jj_la == 0
2077: && jj_scanpos == jj_lastpos)
2078: return false;
2079: } else if (jj_la == 0
2080: && jj_scanpos == jj_lastpos)
2081: return false;
2082: } else if (jj_la == 0
2083: && jj_scanpos == jj_lastpos)
2084: return false;
2085: } else if (jj_la == 0
2086: && jj_scanpos == jj_lastpos)
2087: return false;
2088: } else if (jj_la == 0
2089: && jj_scanpos == jj_lastpos)
2090: return false;
2091: } else if (jj_la == 0
2092: && jj_scanpos == jj_lastpos)
2093: return false;
2094: } else if (jj_la == 0
2095: && jj_scanpos == jj_lastpos)
2096: return false;
2097: } else if (jj_la == 0
2098: && jj_scanpos == jj_lastpos)
2099: return false;
2100: } else if (jj_la == 0
2101: && jj_scanpos == jj_lastpos)
2102: return false;
2103: } else if (jj_la == 0
2104: && jj_scanpos == jj_lastpos)
2105: return false;
2106: } else if (jj_la == 0
2107: && jj_scanpos == jj_lastpos)
2108: return false;
2109: } else if (jj_la == 0
2110: && jj_scanpos == jj_lastpos)
2111: return false;
2112: } else if (jj_la == 0
2113: && jj_scanpos == jj_lastpos)
2114: return false;
2115: } else if (jj_la == 0
2116: && jj_scanpos == jj_lastpos)
2117: return false;
2118: } else if (jj_la == 0
2119: && jj_scanpos == jj_lastpos)
2120: return false;
2121: } else if (jj_la == 0
2122: && jj_scanpos == jj_lastpos)
2123: return false;
2124: } else if (jj_la == 0
2125: && jj_scanpos == jj_lastpos)
2126: return false;
2127: } else if (jj_la == 0
2128: && jj_scanpos == jj_lastpos)
2129: return false;
2130: } else if (jj_la == 0
2131: && jj_scanpos == jj_lastpos)
2132: return false;
2133: } else if (jj_la == 0
2134: && jj_scanpos == jj_lastpos)
2135: return false;
2136: } else if (jj_la == 0
2137: && jj_scanpos == jj_lastpos)
2138: return false;
2139: } else if (jj_la == 0
2140: && jj_scanpos == jj_lastpos)
2141: return false;
2142: } else if (jj_la == 0
2143: && jj_scanpos == jj_lastpos)
2144: return false;
2145: } else if (jj_la == 0
2146: && jj_scanpos == jj_lastpos)
2147: return false;
2148: } else if (jj_la == 0
2149: && jj_scanpos == jj_lastpos)
2150: return false;
2151: } else if (jj_la == 0
2152: && jj_scanpos == jj_lastpos)
2153: return false;
2154: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2155: return false;
2156: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2157: return false;
2158: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2159: return false;
2160: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2161: return false;
2162: return false;
2163: }
2164:
2165: final private boolean jj_3R_111() {
2166: if (jj_scan_token(DIV))
2167: return true;
2168: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2169: return false;
2170: return false;
2171: }
2172:
2173: final private boolean jj_3R_110() {
2174: if (jj_scan_token(MOD))
2175: return true;
2176: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2177: return false;
2178: return false;
2179: }
2180:
2181: final private boolean jj_3R_109() {
2182: if (jj_scan_token(AND))
2183: return true;
2184: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2185: return false;
2186: return false;
2187: }
2188:
2189: final private boolean jj_3R_108() {
2190: if (jj_scan_token(OR))
2191: return true;
2192: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2193: return false;
2194: return false;
2195: }
2196:
2197: final private boolean jj_3R_107() {
2198: if (jj_scan_token(NCName))
2199: return true;
2200: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2201: return false;
2202: return false;
2203: }
2204:
2205: final private boolean jj_3R_173() {
2206: if (jj_scan_token(MINUS))
2207: return true;
2208: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2209: return false;
2210: if (jj_3R_170())
2211: return true;
2212: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2213: return false;
2214: return false;
2215: }
2216:
2217: final private boolean jj_3R_98() {
2218: Token xsp;
2219: xsp = jj_scanpos;
2220: if (jj_3R_107()) {
2221: jj_scanpos = xsp;
2222: if (jj_3R_108()) {
2223: jj_scanpos = xsp;
2224: if (jj_3R_109()) {
2225: jj_scanpos = xsp;
2226: if (jj_3R_110()) {
2227: jj_scanpos = xsp;
2228: if (jj_3R_111())
2229: return true;
2230: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2231: return false;
2232: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2233: return false;
2234: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2235: return false;
2236: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2237: return false;
2238: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2239: return false;
2240: return false;
2241: }
2242:
2243: final private boolean jj_3R_171() {
2244: Token xsp;
2245: xsp = jj_scanpos;
2246: if (jj_3R_174()) {
2247: jj_scanpos = xsp;
2248: if (jj_3R_175()) {
2249: jj_scanpos = xsp;
2250: if (jj_3R_176())
2251: return true;
2252: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2253: return false;
2254: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2255: return false;
2256: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2257: return false;
2258: return false;
2259: }
2260:
2261: final private boolean jj_3R_172() {
2262: if (jj_3R_177())
2263: return true;
2264: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2265: return false;
2266: return false;
2267: }
2268:
2269: final private boolean jj_3R_153() {
2270: if (jj_scan_token(86))
2271: return true;
2272: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2273: return false;
2274: return false;
2275: }
2276:
2277: final private boolean jj_3R_130() {
2278: Token xsp;
2279: xsp = jj_scanpos;
2280: if (jj_3R_153())
2281: jj_scanpos = xsp;
2282: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2283: return false;
2284: return false;
2285: }
2286:
2287: final private boolean jj_3R_54() {
2288: if (jj_scan_token(FUNCTION_FORMAT_NUMBER))
2289: return true;
2290: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2291: return false;
2292: return false;
2293: }
2294:
2295: final private boolean jj_3R_170() {
2296: Token xsp;
2297: xsp = jj_scanpos;
2298: if (jj_3R_172()) {
2299: jj_scanpos = xsp;
2300: if (jj_3R_173())
2301: return true;
2302: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2303: return false;
2304: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2305: return false;
2306: return false;
2307: }
2308:
2309: final private boolean jj_3R_53() {
2310: if (jj_scan_token(FUNCTION_KEY))
2311: return true;
2312: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2313: return false;
2314: return false;
2315: }
2316:
2317: final private boolean jj_3R_52() {
2318: if (jj_scan_token(FUNCTION_ROUND))
2319: return true;
2320: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2321: return false;
2322: return false;
2323: }
2324:
2325: final private boolean jj_3R_51() {
2326: if (jj_scan_token(FUNCTION_CEILING))
2327: return true;
2328: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2329: return false;
2330: return false;
2331: }
2332:
2333: final private boolean jj_3R_50() {
2334: if (jj_scan_token(FUNCTION_FLOOR))
2335: return true;
2336: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2337: return false;
2338: return false;
2339: }
2340:
2341: final private boolean jj_3R_49() {
2342: if (jj_scan_token(FUNCTION_SUM))
2343: return true;
2344: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2345: return false;
2346: return false;
2347: }
2348:
2349: final private boolean jj_3R_48() {
2350: if (jj_scan_token(FUNCTION_NUMBER))
2351: return true;
2352: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2353: return false;
2354: return false;
2355: }
2356:
2357: final private boolean jj_3R_176() {
2358: if (jj_scan_token(MOD))
2359: return true;
2360: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2361: return false;
2362: if (jj_3R_170())
2363: return true;
2364: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2365: return false;
2366: return false;
2367: }
2368:
2369: final private boolean jj_3R_47() {
2370: if (jj_scan_token(FUNCTION_LANG))
2371: return true;
2372: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2373: return false;
2374: return false;
2375: }
2376:
2377: final private boolean jj_3R_175() {
2378: if (jj_scan_token(DIV))
2379: return true;
2380: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2381: return false;
2382: if (jj_3R_170())
2383: return true;
2384: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2385: return false;
2386: return false;
2387: }
2388:
2389: final private boolean jj_3R_46() {
2390: if (jj_scan_token(FUNCTION_NULL))
2391: return true;
2392: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2393: return false;
2394: return false;
2395: }
2396:
2397: final private boolean jj_3R_174() {
2398: if (jj_scan_token(88))
2399: return true;
2400: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2401: return false;
2402: if (jj_3R_170())
2403: return true;
2404: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2405: return false;
2406: return false;
2407: }
2408:
2409: final private boolean jj_3R_45() {
2410: if (jj_scan_token(FUNCTION_FALSE))
2411: return true;
2412: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2413: return false;
2414: return false;
2415: }
2416:
2417: final private boolean jj_3R_44() {
2418: if (jj_scan_token(FUNCTION_TRUE))
2419: return true;
2420: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2421: return false;
2422: return false;
2423: }
2424:
2425: final private boolean jj_3R_43() {
2426: if (jj_scan_token(FUNCTION_NOT))
2427: return true;
2428: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2429: return false;
2430: return false;
2431: }
2432:
2433: final private boolean jj_3R_42() {
2434: if (jj_scan_token(FUNCTION_BOOLEAN))
2435: return true;
2436: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2437: return false;
2438: return false;
2439: }
2440:
2441: final private boolean jj_3R_41() {
2442: if (jj_scan_token(FUNCTION_TRANSLATE))
2443: return true;
2444: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2445: return false;
2446: return false;
2447: }
2448:
2449: final private boolean jj_3R_116() {
2450: if (jj_scan_token(84))
2451: return true;
2452: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2453: return false;
2454: if (jj_3R_104())
2455: return true;
2456: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2457: return false;
2458: if (jj_scan_token(85))
2459: return true;
2460: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2461: return false;
2462: return false;
2463: }
2464:
2465: final private boolean jj_3R_40() {
2466: if (jj_scan_token(FUNCTION_NORMALIZE_SPACE))
2467: return true;
2468: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2469: return false;
2470: return false;
2471: }
2472:
2473: final private boolean jj_3R_39() {
2474: if (jj_scan_token(FUNCTION_STRING_LENGTH))
2475: return true;
2476: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2477: return false;
2478: return false;
2479: }
2480:
2481: final private boolean jj_3R_38() {
2482: if (jj_scan_token(FUNCTION_SUBSTRING))
2483: return true;
2484: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2485: return false;
2486: return false;
2487: }
2488:
2489: final private boolean jj_3R_37() {
2490: if (jj_scan_token(FUNCTION_SUBSTRING_AFTER))
2491: return true;
2492: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2493: return false;
2494: return false;
2495: }
2496:
2497: final private boolean jj_3R_36() {
2498: if (jj_scan_token(FUNCTION_SUBSTRING_BEFORE))
2499: return true;
2500: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2501: return false;
2502: return false;
2503: }
2504:
2505: final private boolean jj_3R_168() {
2506: if (jj_3R_170())
2507: return true;
2508: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2509: return false;
2510: Token xsp;
2511: while (true) {
2512: xsp = jj_scanpos;
2513: if (jj_3R_171()) {
2514: jj_scanpos = xsp;
2515: break;
2516: }
2517: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2518: return false;
2519: }
2520: return false;
2521: }
2522:
2523: final private boolean jj_3R_35() {
2524: if (jj_scan_token(FUNCTION_CONTAINS))
2525: return true;
2526: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2527: return false;
2528: return false;
2529: }
2530:
2531: final private boolean jj_3R_34() {
2532: if (jj_scan_token(FUNCTION_STARTS_WITH))
2533: return true;
2534: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2535: return false;
2536: return false;
2537: }
2538:
2539: final private boolean jj_3R_33() {
2540: if (jj_scan_token(FUNCTION_CONCAT))
2541: return true;
2542: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2543: return false;
2544: return false;
2545: }
2546:
2547: final private boolean jj_3R_32() {
2548: if (jj_scan_token(FUNCTION_STRING))
2549: return true;
2550: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2551: return false;
2552: return false;
2553: }
2554:
2555: final private boolean jj_3R_31() {
2556: if (jj_scan_token(FUNCTION_NAME))
2557: return true;
2558: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2559: return false;
2560: return false;
2561: }
2562:
2563: final private boolean jj_3R_30() {
2564: if (jj_scan_token(FUNCTION_NAMESPACE_URI))
2565: return true;
2566: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2567: return false;
2568: return false;
2569: }
2570:
2571: final private boolean jj_3R_29() {
2572: if (jj_scan_token(FUNCTION_LOCAL_NAME))
2573: return true;
2574: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2575: return false;
2576: return false;
2577: }
2578:
2579: final private boolean jj_3R_169() {
2580: if (jj_scan_token(MINUS))
2581: return true;
2582: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2583: return false;
2584: if (jj_3R_168())
2585: return true;
2586: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2587: return false;
2588: return false;
2589: }
2590:
2591: final private boolean jj_3R_28() {
2592: if (jj_scan_token(FUNCTION_ID))
2593: return true;
2594: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2595: return false;
2596: return false;
2597: }
2598:
2599: final private boolean jj_3R_27() {
2600: if (jj_scan_token(FUNCTION_COUNT))
2601: return true;
2602: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2603: return false;
2604: return false;
2605: }
2606:
2607: final private boolean jj_3R_152() {
2608: if (jj_scan_token(AXIS_DESCENDANT_OR_SELF))
2609: return true;
2610: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2611: return false;
2612: return false;
2613: }
2614:
2615: final private boolean jj_3R_26() {
2616: if (jj_scan_token(FUNCTION_POSITION))
2617: return true;
2618: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2619: return false;
2620: return false;
2621: }
2622:
2623: final private boolean jj_3R_25() {
2624: if (jj_scan_token(FUNCTION_LAST))
2625: return true;
2626: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2627: return false;
2628: return false;
2629: }
2630:
2631: final private boolean jj_3R_151() {
2632: if (jj_scan_token(AXIS_PRECEDING_SIBLING))
2633: return true;
2634: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2635: return false;
2636: return false;
2637: }
2638:
2639: final private boolean jj_3R_24() {
2640: if (jj_scan_token(PI))
2641: return true;
2642: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2643: return false;
2644: return false;
2645: }
2646:
2647: final private boolean jj_3R_150() {
2648: if (jj_scan_token(AXIS_FOLLOWING_SIBLING))
2649: return true;
2650: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2651: return false;
2652: return false;
2653: }
2654:
2655: final private boolean jj_3R_23() {
2656: if (jj_scan_token(COMMENT))
2657: return true;
2658: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2659: return false;
2660: return false;
2661: }
2662:
2663: final private boolean jj_3R_149() {
2664: if (jj_scan_token(AXIS_ANCESTOR_OR_SELF))
2665: return true;
2666: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2667: return false;
2668: return false;
2669: }
2670:
2671: final private boolean jj_3R_163() {
2672: if (jj_scan_token(PLUS))
2673: return true;
2674: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2675: return false;
2676: if (jj_3R_162())
2677: return true;
2678: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2679: return false;
2680: return false;
2681: }
2682:
2683: final private boolean jj_3R_22() {
2684: if (jj_scan_token(TEXT))
2685: return true;
2686: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2687: return false;
2688: return false;
2689: }
2690:
2691: final private boolean jj_3R_148() {
2692: if (jj_scan_token(AXIS_DESCENDANT))
2693: return true;
2694: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2695: return false;
2696: return false;
2697: }
2698:
2699: final private boolean jj_3R_21() {
2700: if (jj_scan_token(NODE))
2701: return true;
2702: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2703: return false;
2704: return false;
2705: }
2706:
2707: final private boolean jj_3R_147() {
2708: if (jj_scan_token(AXIS_FOLLOWING))
2709: return true;
2710: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2711: return false;
2712: return false;
2713: }
2714:
2715: final private boolean jj_3R_20() {
2716: if (jj_3R_98())
2717: return true;
2718: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2719: return false;
2720: return false;
2721: }
2722:
2723: final private boolean jj_3R_146() {
2724: if (jj_scan_token(AXIS_PRECEDING))
2725: return true;
2726: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2727: return false;
2728: return false;
2729: }
2730:
2731: final private boolean jj_3R_145() {
2732: if (jj_scan_token(AXIS_NAMESPACE))
2733: return true;
2734: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2735: return false;
2736: return false;
2737: }
2738:
2739: final private boolean jj_3R_162() {
2740: if (jj_3R_168())
2741: return true;
2742: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2743: return false;
2744: Token xsp;
2745: while (true) {
2746: xsp = jj_scanpos;
2747: if (jj_3R_169()) {
2748: jj_scanpos = xsp;
2749: break;
2750: }
2751: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2752: return false;
2753: }
2754: return false;
2755: }
2756:
2757: final private boolean jj_3R_144() {
2758: if (jj_scan_token(AXIS_ATTRIBUTE))
2759: return true;
2760: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2761: return false;
2762: return false;
2763: }
2764:
2765: final private boolean jj_3R_143() {
2766: if (jj_scan_token(AXIS_ANCESTOR))
2767: return true;
2768: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2769: return false;
2770: return false;
2771: }
2772:
2773: final private boolean jj_3R_142() {
2774: if (jj_scan_token(AXIS_PARENT))
2775: return true;
2776: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2777: return false;
2778: return false;
2779: }
2780:
2781: final private boolean jj_3R_15() {
2782: Token xsp;
2783: xsp = jj_scanpos;
2784: if (jj_3R_20()) {
2785: jj_scanpos = xsp;
2786: if (jj_3R_21()) {
2787: jj_scanpos = xsp;
2788: if (jj_3R_22()) {
2789: jj_scanpos = xsp;
2790: if (jj_3R_23()) {
2791: jj_scanpos = xsp;
2792: if (jj_3R_24()) {
2793: jj_scanpos = xsp;
2794: if (jj_3R_25()) {
2795: jj_scanpos = xsp;
2796: if (jj_3R_26()) {
2797: jj_scanpos = xsp;
2798: if (jj_3R_27()) {
2799: jj_scanpos = xsp;
2800: if (jj_3R_28()) {
2801: jj_scanpos = xsp;
2802: if (jj_3R_29()) {
2803: jj_scanpos = xsp;
2804: if (jj_3R_30()) {
2805: jj_scanpos = xsp;
2806: if (jj_3R_31()) {
2807: jj_scanpos = xsp;
2808: if (jj_3R_32()) {
2809: jj_scanpos = xsp;
2810: if (jj_3R_33()) {
2811: jj_scanpos = xsp;
2812: if (jj_3R_34()) {
2813: jj_scanpos = xsp;
2814: if (jj_3R_35()) {
2815: jj_scanpos = xsp;
2816: if (jj_3R_36()) {
2817: jj_scanpos = xsp;
2818: if (jj_3R_37()) {
2819: jj_scanpos = xsp;
2820: if (jj_3R_38()) {
2821: jj_scanpos = xsp;
2822: if (jj_3R_39()) {
2823: jj_scanpos = xsp;
2824: if (jj_3R_40()) {
2825: jj_scanpos = xsp;
2826: if (jj_3R_41()) {
2827: jj_scanpos = xsp;
2828: if (jj_3R_42()) {
2829: jj_scanpos = xsp;
2830: if (jj_3R_43()) {
2831: jj_scanpos = xsp;
2832: if (jj_3R_44()) {
2833: jj_scanpos = xsp;
2834: if (jj_3R_45()) {
2835: jj_scanpos = xsp;
2836: if (jj_3R_46()) {
2837: jj_scanpos = xsp;
2838: if (jj_3R_47()) {
2839: jj_scanpos = xsp;
2840: if (jj_3R_48()) {
2841: jj_scanpos = xsp;
2842: if (jj_3R_49()) {
2843: jj_scanpos = xsp;
2844: if (jj_3R_50()) {
2845: jj_scanpos = xsp;
2846: if (jj_3R_51()) {
2847: jj_scanpos = xsp;
2848: if (jj_3R_52()) {
2849: jj_scanpos = xsp;
2850: if (jj_3R_53()) {
2851: jj_scanpos = xsp;
2852: if (jj_3R_54())
2853: return true;
2854: if (jj_la == 0
2855: && jj_scanpos == jj_lastpos)
2856: return false;
2857: } else if (jj_la == 0
2858: && jj_scanpos == jj_lastpos)
2859: return false;
2860: } else if (jj_la == 0
2861: && jj_scanpos == jj_lastpos)
2862: return false;
2863: } else if (jj_la == 0
2864: && jj_scanpos == jj_lastpos)
2865: return false;
2866: } else if (jj_la == 0
2867: && jj_scanpos == jj_lastpos)
2868: return false;
2869: } else if (jj_la == 0
2870: && jj_scanpos == jj_lastpos)
2871: return false;
2872: } else if (jj_la == 0
2873: && jj_scanpos == jj_lastpos)
2874: return false;
2875: } else if (jj_la == 0
2876: && jj_scanpos == jj_lastpos)
2877: return false;
2878: } else if (jj_la == 0
2879: && jj_scanpos == jj_lastpos)
2880: return false;
2881: } else if (jj_la == 0
2882: && jj_scanpos == jj_lastpos)
2883: return false;
2884: } else if (jj_la == 0
2885: && jj_scanpos == jj_lastpos)
2886: return false;
2887: } else if (jj_la == 0
2888: && jj_scanpos == jj_lastpos)
2889: return false;
2890: } else if (jj_la == 0
2891: && jj_scanpos == jj_lastpos)
2892: return false;
2893: } else if (jj_la == 0
2894: && jj_scanpos == jj_lastpos)
2895: return false;
2896: } else if (jj_la == 0
2897: && jj_scanpos == jj_lastpos)
2898: return false;
2899: } else if (jj_la == 0
2900: && jj_scanpos == jj_lastpos)
2901: return false;
2902: } else if (jj_la == 0
2903: && jj_scanpos == jj_lastpos)
2904: return false;
2905: } else if (jj_la == 0
2906: && jj_scanpos == jj_lastpos)
2907: return false;
2908: } else if (jj_la == 0
2909: && jj_scanpos == jj_lastpos)
2910: return false;
2911: } else if (jj_la == 0
2912: && jj_scanpos == jj_lastpos)
2913: return false;
2914: } else if (jj_la == 0
2915: && jj_scanpos == jj_lastpos)
2916: return false;
2917: } else if (jj_la == 0
2918: && jj_scanpos == jj_lastpos)
2919: return false;
2920: } else if (jj_la == 0
2921: && jj_scanpos == jj_lastpos)
2922: return false;
2923: } else if (jj_la == 0
2924: && jj_scanpos == jj_lastpos)
2925: return false;
2926: } else if (jj_la == 0
2927: && jj_scanpos == jj_lastpos)
2928: return false;
2929: } else if (jj_la == 0
2930: && jj_scanpos == jj_lastpos)
2931: return false;
2932: } else if (jj_la == 0
2933: && jj_scanpos == jj_lastpos)
2934: return false;
2935: } else if (jj_la == 0
2936: && jj_scanpos == jj_lastpos)
2937: return false;
2938: } else if (jj_la == 0
2939: && jj_scanpos == jj_lastpos)
2940: return false;
2941: } else if (jj_la == 0
2942: && jj_scanpos == jj_lastpos)
2943: return false;
2944: } else if (jj_la == 0
2945: && jj_scanpos == jj_lastpos)
2946: return false;
2947: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2948: return false;
2949: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2950: return false;
2951: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2952: return false;
2953: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
2954: return false;
2955: return false;
2956: }
2957:
2958: final private boolean jj_3R_141() {
2959: if (jj_scan_token(AXIS_CHILD))
2960: return true;
2961: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2962: return false;
2963: return false;
2964: }
2965:
2966: final private boolean jj_3R_140() {
2967: if (jj_scan_token(AXIS_SELF))
2968: return true;
2969: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2970: return false;
2971: return false;
2972: }
2973:
2974: final private boolean jj_3R_129() {
2975: Token xsp;
2976: xsp = jj_scanpos;
2977: if (jj_3R_140()) {
2978: jj_scanpos = xsp;
2979: if (jj_3R_141()) {
2980: jj_scanpos = xsp;
2981: if (jj_3R_142()) {
2982: jj_scanpos = xsp;
2983: if (jj_3R_143()) {
2984: jj_scanpos = xsp;
2985: if (jj_3R_144()) {
2986: jj_scanpos = xsp;
2987: if (jj_3R_145()) {
2988: jj_scanpos = xsp;
2989: if (jj_3R_146()) {
2990: jj_scanpos = xsp;
2991: if (jj_3R_147()) {
2992: jj_scanpos = xsp;
2993: if (jj_3R_148()) {
2994: jj_scanpos = xsp;
2995: if (jj_3R_149()) {
2996: jj_scanpos = xsp;
2997: if (jj_3R_150()) {
2998: jj_scanpos = xsp;
2999: if (jj_3R_151()) {
3000: jj_scanpos = xsp;
3001: if (jj_3R_152())
3002: return true;
3003: if (jj_la == 0
3004: && jj_scanpos == jj_lastpos)
3005: return false;
3006: } else if (jj_la == 0
3007: && jj_scanpos == jj_lastpos)
3008: return false;
3009: } else if (jj_la == 0
3010: && jj_scanpos == jj_lastpos)
3011: return false;
3012: } else if (jj_la == 0
3013: && jj_scanpos == jj_lastpos)
3014: return false;
3015: } else if (jj_la == 0
3016: && jj_scanpos == jj_lastpos)
3017: return false;
3018: } else if (jj_la == 0
3019: && jj_scanpos == jj_lastpos)
3020: return false;
3021: } else if (jj_la == 0
3022: && jj_scanpos == jj_lastpos)
3023: return false;
3024: } else if (jj_la == 0
3025: && jj_scanpos == jj_lastpos)
3026: return false;
3027: } else if (jj_la == 0
3028: && jj_scanpos == jj_lastpos)
3029: return false;
3030: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3031: return false;
3032: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3033: return false;
3034: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3035: return false;
3036: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3037: return false;
3038: return false;
3039: }
3040:
3041: final private boolean jj_3R_159() {
3042: Token xsp;
3043: xsp = jj_scanpos;
3044: if (jj_3R_164()) {
3045: jj_scanpos = xsp;
3046: if (jj_3R_165()) {
3047: jj_scanpos = xsp;
3048: if (jj_3R_166()) {
3049: jj_scanpos = xsp;
3050: if (jj_3R_167())
3051: return true;
3052: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3053: return false;
3054: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3055: return false;
3056: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3057: return false;
3058: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3059: return false;
3060: return false;
3061: }
3062:
3063: final private boolean jj_3R_158() {
3064: if (jj_3R_162())
3065: return true;
3066: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3067: return false;
3068: Token xsp;
3069: while (true) {
3070: xsp = jj_scanpos;
3071: if (jj_3R_163()) {
3072: jj_scanpos = xsp;
3073: break;
3074: }
3075: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3076: return false;
3077: }
3078: return false;
3079: }
3080:
3081: final private boolean jj_3R_122() {
3082: if (jj_3R_130())
3083: return true;
3084: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3085: return false;
3086: return false;
3087: }
3088:
3089: final private boolean jj_3R_121() {
3090: if (jj_3R_129())
3091: return true;
3092: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3093: return false;
3094: return false;
3095: }
3096:
3097: final private boolean jj_3R_167() {
3098: if (jj_scan_token(GTE))
3099: return true;
3100: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3101: return false;
3102: if (jj_3R_158())
3103: return true;
3104: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3105: return false;
3106: return false;
3107: }
3108:
3109: final private boolean jj_3R_112() {
3110: Token xsp;
3111: xsp = jj_scanpos;
3112: if (jj_3R_121()) {
3113: jj_scanpos = xsp;
3114: if (jj_3R_122())
3115: return true;
3116: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3117: return false;
3118: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3119: return false;
3120: return false;
3121: }
3122:
3123: final private boolean jj_3R_166() {
3124: if (jj_scan_token(LTE))
3125: return true;
3126: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3127: return false;
3128: if (jj_3R_158())
3129: return true;
3130: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3131: return false;
3132: return false;
3133: }
3134:
3135: final private boolean jj_3R_165() {
3136: if (jj_scan_token(GT))
3137: return true;
3138: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3139: return false;
3140: if (jj_3R_158())
3141: return true;
3142: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3143: return false;
3144: return false;
3145: }
3146:
3147: final private boolean jj_3R_157() {
3148: Token xsp;
3149: xsp = jj_scanpos;
3150: if (jj_3R_160()) {
3151: jj_scanpos = xsp;
3152: if (jj_3R_161())
3153: return true;
3154: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3155: return false;
3156: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3157: return false;
3158: return false;
3159: }
3160:
3161: final private boolean jj_3R_164() {
3162: if (jj_scan_token(LT))
3163: return true;
3164: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3165: return false;
3166: if (jj_3R_158())
3167: return true;
3168: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3169: return false;
3170: return false;
3171: }
3172:
3173: final private boolean jj_3R_156() {
3174: if (jj_3R_158())
3175: return true;
3176: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3177: return false;
3178: Token xsp;
3179: while (true) {
3180: xsp = jj_scanpos;
3181: if (jj_3R_159()) {
3182: jj_scanpos = xsp;
3183: break;
3184: }
3185: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3186: return false;
3187: }
3188: return false;
3189: }
3190:
3191: final private boolean jj_3R_161() {
3192: if (jj_scan_token(NEQ))
3193: return true;
3194: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3195: return false;
3196: if (jj_3R_156())
3197: return true;
3198: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3199: return false;
3200: return false;
3201: }
3202:
3203: final private boolean jj_3R_160() {
3204: if (jj_scan_token(EQ))
3205: return true;
3206: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3207: return false;
3208: if (jj_3R_156())
3209: return true;
3210: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3211: return false;
3212: return false;
3213: }
3214:
3215: final private boolean jj_3R_102() {
3216: if (jj_3R_116())
3217: return true;
3218: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3219: return false;
3220: return false;
3221: }
3222:
3223: final private boolean jj_3_4() {
3224: if (jj_scan_token(PI))
3225: return true;
3226: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3227: return false;
3228: return false;
3229: }
3230:
3231: final private boolean jj_3_3() {
3232: if (jj_3R_17())
3233: return true;
3234: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3235: return false;
3236: if (jj_scan_token(80))
3237: return true;
3238: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3239: return false;
3240: if (jj_scan_token(81))
3241: return true;
3242: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3243: return false;
3244: return false;
3245: }
3246:
3247: final private boolean jj_3R_101() {
3248: if (jj_scan_token(83))
3249: return true;
3250: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3251: return false;
3252: return false;
3253: }
3254:
3255: final private boolean jj_3R_100() {
3256: if (jj_scan_token(82))
3257: return true;
3258: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3259: return false;
3260: return false;
3261: }
3262:
3263: final private boolean jj_3R_115() {
3264: if (jj_3R_123())
3265: return true;
3266: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3267: return false;
3268: return false;
3269: }
3270:
3271: final private boolean jj_3R_134() {
3272: if (jj_3R_156())
3273: return true;
3274: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3275: return false;
3276: Token xsp;
3277: while (true) {
3278: xsp = jj_scanpos;
3279: if (jj_3R_157()) {
3280: jj_scanpos = xsp;
3281: break;
3282: }
3283: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3284: return false;
3285: }
3286: return false;
3287: }
3288:
3289: final private boolean jj_3R_114() {
3290: if (jj_scan_token(PI))
3291: return true;
3292: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3293: return false;
3294: if (jj_scan_token(80))
3295: return true;
3296: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3297: return false;
3298: if (jj_scan_token(Literal))
3299: return true;
3300: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3301: return false;
3302: if (jj_scan_token(81))
3303: return true;
3304: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3305: return false;
3306: return false;
3307: }
3308:
3309: final private boolean jj_3R_113() {
3310: if (jj_3R_17())
3311: return true;
3312: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3313: return false;
3314: if (jj_scan_token(80))
3315: return true;
3316: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3317: return false;
3318: if (jj_scan_token(81))
3319: return true;
3320: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3321: return false;
3322: return false;
3323: }
3324:
3325: final private boolean jj_3R_99() {
3326: if (jj_3R_112())
3327: return true;
3328: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3329: return false;
3330: Token xsp;
3331: xsp = jj_scanpos;
3332: if (jj_3R_113()) {
3333: jj_scanpos = xsp;
3334: if (jj_3R_114()) {
3335: jj_scanpos = xsp;
3336: if (jj_3R_115())
3337: return true;
3338: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3339: return false;
3340: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3341: return false;
3342: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3343: return false;
3344: return false;
3345: }
3346:
3347: final private boolean jj_3R_135() {
3348: if (jj_scan_token(AND))
3349: return true;
3350: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3351: return false;
3352: if (jj_3R_134())
3353: return true;
3354: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3355: return false;
3356: return false;
3357: }
3358:
3359: final private boolean jj_3R_57() {
3360: Token xsp;
3361: xsp = jj_scanpos;
3362: if (jj_3R_99()) {
3363: jj_scanpos = xsp;
3364: if (jj_3R_100()) {
3365: jj_scanpos = xsp;
3366: if (jj_3R_101())
3367: return true;
3368: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3369: return false;
3370: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3371: return false;
3372: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3373: return false;
3374: while (true) {
3375: xsp = jj_scanpos;
3376: if (jj_3R_102()) {
3377: jj_scanpos = xsp;
3378: break;
3379: }
3380: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3381: return false;
3382: }
3383: return false;
3384: }
3385:
3386: final private boolean jj_3R_125() {
3387: if (jj_3R_134())
3388: return true;
3389: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3390: return false;
3391: Token xsp;
3392: while (true) {
3393: xsp = jj_scanpos;
3394: if (jj_3R_135()) {
3395: jj_scanpos = xsp;
3396: break;
3397: }
3398: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3399: return false;
3400: }
3401: return false;
3402: }
3403:
3404: final private boolean jj_3R_193() {
3405: if (jj_3R_16())
3406: return true;
3407: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3408: return false;
3409: return false;
3410: }
3411:
3412: final private boolean jj_3R_56() {
3413: if (jj_scan_token(SLASHSLASH))
3414: return true;
3415: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3416: return false;
3417: return false;
3418: }
3419:
3420: final private boolean jj_3R_55() {
3421: if (jj_scan_token(SLASH))
3422: return true;
3423: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3424: return false;
3425: return false;
3426: }
3427:
3428: final private boolean jj_3R_126() {
3429: if (jj_scan_token(OR))
3430: return true;
3431: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3432: return false;
3433: if (jj_3R_125())
3434: return true;
3435: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3436: return false;
3437: return false;
3438: }
3439:
3440: final private boolean jj_3R_16() {
3441: Token xsp;
3442: xsp = jj_scanpos;
3443: if (jj_3R_55()) {
3444: jj_scanpos = xsp;
3445: if (jj_3R_56())
3446: return true;
3447: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3448: return false;
3449: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3450: return false;
3451: if (jj_3R_57())
3452: return true;
3453: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3454: return false;
3455: return false;
3456: }
3457:
3458: final private boolean jj_3R_190() {
3459: if (jj_3R_16())
3460: return true;
3461: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3462: return false;
3463: return false;
3464: }
3465:
3466: final private boolean jj_3R_118() {
3467: if (jj_3R_125())
3468: return true;
3469: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3470: return false;
3471: Token xsp;
3472: while (true) {
3473: xsp = jj_scanpos;
3474: if (jj_3R_126()) {
3475: jj_scanpos = xsp;
3476: break;
3477: }
3478: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3479: return false;
3480: }
3481: return false;
3482: }
3483:
3484: final private boolean jj_3R_188() {
3485: if (jj_3R_57())
3486: return true;
3487: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3488: return false;
3489: Token xsp;
3490: while (true) {
3491: xsp = jj_scanpos;
3492: if (jj_3R_190()) {
3493: jj_scanpos = xsp;
3494: break;
3495: }
3496: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3497: return false;
3498: }
3499: return false;
3500: }
3501:
3502: final private boolean jj_3_2() {
3503: if (jj_3R_16())
3504: return true;
3505: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3506: return false;
3507: return false;
3508: }
3509:
3510: final private boolean jj_3R_185() {
3511: if (jj_3R_16())
3512: return true;
3513: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3514: return false;
3515: return false;
3516: }
3517:
3518: final private boolean jj_3R_192() {
3519: if (jj_scan_token(SLASH))
3520: return true;
3521: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3522: return false;
3523: return false;
3524: }
3525:
3526: final private boolean jj_3R_191() {
3527: if (jj_3R_16())
3528: return true;
3529: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3530: return false;
3531: Token xsp;
3532: while (true) {
3533: xsp = jj_scanpos;
3534: if (jj_3R_193()) {
3535: jj_scanpos = xsp;
3536: break;
3537: }
3538: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3539: return false;
3540: }
3541: return false;
3542: }
3543:
3544: final private boolean jj_3R_184() {
3545: if (jj_3R_116())
3546: return true;
3547: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3548: return false;
3549: return false;
3550: }
3551:
3552: final private boolean jj_3R_189() {
3553: Token xsp;
3554: xsp = jj_scanpos;
3555: if (jj_3R_191()) {
3556: jj_scanpos = xsp;
3557: if (jj_3R_192())
3558: return true;
3559: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3560: return false;
3561: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3562: return false;
3563: return false;
3564: }
3565:
3566: final private boolean jj_3R_182() {
3567: if (jj_3R_19())
3568: return true;
3569: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3570: return false;
3571: Token xsp;
3572: while (true) {
3573: xsp = jj_scanpos;
3574: if (jj_3R_184()) {
3575: jj_scanpos = xsp;
3576: break;
3577: }
3578: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3579: return false;
3580: }
3581: while (true) {
3582: xsp = jj_scanpos;
3583: if (jj_3R_185()) {
3584: jj_scanpos = xsp;
3585: break;
3586: }
3587: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3588: return false;
3589: }
3590: return false;
3591: }
3592:
3593: final private boolean jj_3_6() {
3594: if (jj_3R_19())
3595: return true;
3596: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3597: return false;
3598: return false;
3599: }
3600:
3601: final private boolean jj_3R_187() {
3602: if (jj_3R_189())
3603: return true;
3604: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3605: return false;
3606: return false;
3607: }
3608:
3609: final private boolean jj_3R_186() {
3610: if (jj_3R_188())
3611: return true;
3612: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3613: return false;
3614: return false;
3615: }
3616:
3617: final private boolean jj_3R_183() {
3618: Token xsp;
3619: xsp = jj_scanpos;
3620: if (jj_3R_186()) {
3621: jj_scanpos = xsp;
3622: if (jj_3R_187())
3623: return true;
3624: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3625: return false;
3626: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3627: return false;
3628: return false;
3629: }
3630:
3631: final private boolean jj_3R_181() {
3632: if (jj_3R_183())
3633: return true;
3634: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3635: return false;
3636: return false;
3637: }
3638:
3639: final private boolean jj_3R_180() {
3640: if (jj_3R_182())
3641: return true;
3642: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3643: return false;
3644: return false;
3645: }
3646:
3647: final private boolean jj_3R_178() {
3648: Token xsp;
3649: xsp = jj_scanpos;
3650: if (jj_3R_180()) {
3651: jj_scanpos = xsp;
3652: if (jj_3R_181())
3653: return true;
3654: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3655: return false;
3656: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3657: return false;
3658: return false;
3659: }
3660:
3661: final private boolean jj_3R_179() {
3662: if (jj_scan_token(UNION))
3663: return true;
3664: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3665: return false;
3666: if (jj_3R_178())
3667: return true;
3668: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3669: return false;
3670: return false;
3671: }
3672:
3673: final private boolean jj_3R_177() {
3674: if (jj_3R_178())
3675: return true;
3676: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3677: return false;
3678: Token xsp;
3679: while (true) {
3680: xsp = jj_scanpos;
3681: if (jj_3R_179()) {
3682: jj_scanpos = xsp;
3683: break;
3684: }
3685: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3686: return false;
3687: }
3688: return false;
3689: }
3690:
3691: final private boolean jj_3R_136() {
3692: if (jj_3R_104())
3693: return true;
3694: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3695: return false;
3696: return false;
3697: }
3698:
3699: final private boolean jj_3R_137() {
3700: if (jj_scan_token(87))
3701: return true;
3702: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3703: return false;
3704: if (jj_3R_136())
3705: return true;
3706: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3707: return false;
3708: return false;
3709: }
3710:
3711: final private boolean jj_3R_127() {
3712: if (jj_3R_136())
3713: return true;
3714: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3715: return false;
3716: Token xsp;
3717: while (true) {
3718: xsp = jj_scanpos;
3719: if (jj_3R_137()) {
3720: jj_scanpos = xsp;
3721: break;
3722: }
3723: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3724: return false;
3725: }
3726: return false;
3727: }
3728:
3729: final private boolean jj_3R_119() {
3730: if (jj_scan_token(80))
3731: return true;
3732: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3733: return false;
3734: Token xsp;
3735: xsp = jj_scanpos;
3736: if (jj_3R_127())
3737: jj_scanpos = xsp;
3738: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3739: return false;
3740: if (jj_scan_token(81))
3741: return true;
3742: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3743: return false;
3744: return false;
3745: }
3746:
3747: final private boolean jj_3R_61() {
3748: if (jj_scan_token(PI))
3749: return true;
3750: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3751: return false;
3752: return false;
3753: }
3754:
3755: final private boolean jj_3R_60() {
3756: if (jj_scan_token(COMMENT))
3757: return true;
3758: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3759: return false;
3760: return false;
3761: }
3762:
3763: final private boolean jj_3R_59() {
3764: if (jj_scan_token(NODE))
3765: return true;
3766: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3767: return false;
3768: return false;
3769: }
3770:
3771: final private boolean jj_3R_58() {
3772: if (jj_scan_token(TEXT))
3773: return true;
3774: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3775: return false;
3776: return false;
3777: }
3778:
3779: final private boolean jj_3_1() {
3780: if (jj_3R_15())
3781: return true;
3782: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3783: return false;
3784: if (jj_scan_token(79))
3785: return true;
3786: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3787: return false;
3788: return false;
3789: }
3790:
3791: final private boolean jj_3R_17() {
3792: Token xsp;
3793: xsp = jj_scanpos;
3794: if (jj_3R_58()) {
3795: jj_scanpos = xsp;
3796: if (jj_3R_59()) {
3797: jj_scanpos = xsp;
3798: if (jj_3R_60()) {
3799: jj_scanpos = xsp;
3800: if (jj_3R_61())
3801: return true;
3802: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3803: return false;
3804: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3805: return false;
3806: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3807: return false;
3808: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3809: return false;
3810: return false;
3811: }
3812:
3813: final private boolean jj_3R_155() {
3814: if (jj_3R_15())
3815: return true;
3816: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3817: return false;
3818: return false;
3819: }
3820:
3821: final private boolean jj_3R_139() {
3822: if (jj_3R_98())
3823: return true;
3824: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3825: return false;
3826: return false;
3827: }
3828:
3829: final private boolean jj_3R_138() {
3830: if (jj_3R_15())
3831: return true;
3832: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3833: return false;
3834: if (jj_scan_token(79))
3835: return true;
3836: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3837: return false;
3838: if (jj_3R_15())
3839: return true;
3840: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3841: return false;
3842: return false;
3843: }
3844:
3845: final private boolean jj_3R_154() {
3846: if (jj_scan_token(88))
3847: return true;
3848: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3849: return false;
3850: return false;
3851: }
3852:
3853: final private boolean jj_3R_132() {
3854: if (jj_3R_15())
3855: return true;
3856: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3857: return false;
3858: return false;
3859: }
3860:
3861: final private boolean jj_3R_105() {
3862: if (jj_3R_18())
3863: return true;
3864: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3865: return false;
3866: if (jj_3R_119())
3867: return true;
3868: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3869: return false;
3870: return false;
3871: }
3872:
3873: final private boolean jj_3R_124() {
3874: if (jj_scan_token(79))
3875: return true;
3876: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3877: return false;
3878: if (jj_3R_15())
3879: return true;
3880: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3881: return false;
3882: return false;
3883: }
3884:
3885: final private boolean jj_3R_133() {
3886: if (jj_scan_token(79))
3887: return true;
3888: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3889: return false;
3890: Token xsp;
3891: xsp = jj_scanpos;
3892: if (jj_3R_154()) {
3893: jj_scanpos = xsp;
3894: if (jj_3R_155())
3895: return true;
3896: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3897: return false;
3898: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3899: return false;
3900: return false;
3901: }
3902:
3903: final private boolean jj_3R_128() {
3904: Token xsp;
3905: xsp = jj_scanpos;
3906: if (jj_3R_138()) {
3907: jj_scanpos = xsp;
3908: if (jj_3R_139())
3909: return true;
3910: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3911: return false;
3912: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3913: return false;
3914: return false;
3915: }
3916:
3917: final private boolean jj_3R_131() {
3918: if (jj_scan_token(88))
3919: return true;
3920: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3921: return false;
3922: return false;
3923: }
3924:
3925: final private boolean jj_3R_123() {
3926: Token xsp;
3927: xsp = jj_scanpos;
3928: if (jj_3R_131()) {
3929: jj_scanpos = xsp;
3930: if (jj_3R_132())
3931: return true;
3932: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3933: return false;
3934: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3935: return false;
3936: xsp = jj_scanpos;
3937: if (jj_3R_133())
3938: jj_scanpos = xsp;
3939: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3940: return false;
3941: return false;
3942: }
3943:
3944: final private boolean jj_3R_106() {
3945: if (jj_3R_120())
3946: return true;
3947: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3948: return false;
3949: if (jj_3R_119())
3950: return true;
3951: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3952: return false;
3953: return false;
3954: }
3955:
3956: final private boolean jj_3R_117() {
3957: if (jj_3R_15())
3958: return true;
3959: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3960: return false;
3961: Token xsp;
3962: xsp = jj_scanpos;
3963: if (jj_3R_124())
3964: jj_scanpos = xsp;
3965: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
3966: return false;
3967: return false;
3968: }
3969:
3970: final private boolean jj_3_5() {
3971: if (jj_3R_18())
3972: return true;
3973: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3974: return false;
3975: if (jj_scan_token(80))
3976: return true;
3977: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3978: return false;
3979: return false;
3980: }
3981:
3982: final private boolean jj_3R_103() {
3983: if (jj_scan_token(VARIABLE))
3984: return true;
3985: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3986: return false;
3987: if (jj_3R_117())
3988: return true;
3989: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3990: return false;
3991: return false;
3992: }
3993:
3994: final private boolean jj_3R_91() {
3995: if (jj_scan_token(FUNCTION_FORMAT_NUMBER))
3996: return true;
3997: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3998: return false;
3999: return false;
4000: }
4001:
4002: final private boolean jj_3R_90() {
4003: if (jj_scan_token(FUNCTION_KEY))
4004: return true;
4005: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4006: return false;
4007: return false;
4008: }
4009:
4010: final private boolean jj_3R_89() {
4011: if (jj_scan_token(FUNCTION_ROUND))
4012: return true;
4013: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4014: return false;
4015: return false;
4016: }
4017:
4018: final private boolean jj_3R_88() {
4019: if (jj_scan_token(FUNCTION_CEILING))
4020: return true;
4021: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4022: return false;
4023: return false;
4024: }
4025:
4026: final private boolean jj_3R_97() {
4027: if (jj_3R_106())
4028: return true;
4029: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4030: return false;
4031: return false;
4032: }
4033:
4034: final private boolean jj_3R_87() {
4035: if (jj_scan_token(FUNCTION_FLOOR))
4036: return true;
4037: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4038: return false;
4039: return false;
4040: }
4041:
4042: final private boolean jj_3R_96() {
4043: if (jj_3R_105())
4044: return true;
4045: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4046: return false;
4047: return false;
4048: }
4049:
4050: final private boolean jj_3R_86() {
4051: if (jj_scan_token(FUNCTION_SUM))
4052: return true;
4053: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4054: return false;
4055: return false;
4056: }
4057:
4058: final private boolean jj_3R_95() {
4059: if (jj_scan_token(Number))
4060: return true;
4061: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4062: return false;
4063: return false;
4064: }
4065:
4066: final private boolean jj_3R_85() {
4067: if (jj_scan_token(FUNCTION_NUMBER))
4068: return true;
4069: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4070: return false;
4071: return false;
4072: }
4073:
4074: final private boolean jj_3R_94() {
4075: if (jj_scan_token(Literal))
4076: return true;
4077: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4078: return false;
4079: return false;
4080: }
4081:
4082: final private boolean jj_3R_84() {
4083: if (jj_scan_token(FUNCTION_LANG))
4084: return true;
4085: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4086: return false;
4087: return false;
4088: }
4089:
4090: final private boolean jj_3R_93() {
4091: if (jj_scan_token(80))
4092: return true;
4093: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4094: return false;
4095: if (jj_3R_104())
4096: return true;
4097: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4098: return false;
4099: if (jj_scan_token(81))
4100: return true;
4101: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4102: return false;
4103: return false;
4104: }
4105:
4106: final private boolean jj_3R_83() {
4107: if (jj_scan_token(FUNCTION_NULL))
4108: return true;
4109: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4110: return false;
4111: return false;
4112: }
4113:
4114: final private boolean jj_3R_92() {
4115: if (jj_3R_103())
4116: return true;
4117: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4118: return false;
4119: return false;
4120: }
4121:
4122: final private boolean jj_3R_82() {
4123: if (jj_scan_token(FUNCTION_FALSE))
4124: return true;
4125: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4126: return false;
4127: return false;
4128: }
4129:
4130: final private boolean jj_3R_81() {
4131: if (jj_scan_token(FUNCTION_TRUE))
4132: return true;
4133: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4134: return false;
4135: return false;
4136: }
4137:
4138: final private boolean jj_3R_120() {
4139: if (jj_3R_128())
4140: return true;
4141: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4142: return false;
4143: return false;
4144: }
4145:
4146: final private boolean jj_3R_80() {
4147: if (jj_scan_token(FUNCTION_NOT))
4148: return true;
4149: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4150: return false;
4151: return false;
4152: }
4153:
4154: final private boolean jj_3R_79() {
4155: if (jj_scan_token(FUNCTION_BOOLEAN))
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_78() {
4163: if (jj_scan_token(FUNCTION_TRANSLATE))
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_77() {
4171: if (jj_scan_token(FUNCTION_NORMALIZE_SPACE))
4172: return true;
4173: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4174: return false;
4175: return false;
4176: }
4177:
4178: final private boolean jj_3R_19() {
4179: Token xsp;
4180: xsp = jj_scanpos;
4181: if (jj_3R_92()) {
4182: jj_scanpos = xsp;
4183: if (jj_3R_93()) {
4184: jj_scanpos = xsp;
4185: if (jj_3R_94()) {
4186: jj_scanpos = xsp;
4187: if (jj_3R_95()) {
4188: jj_scanpos = xsp;
4189: if (jj_3R_96()) {
4190: jj_scanpos = xsp;
4191: if (jj_3R_97())
4192: return true;
4193: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4194: return false;
4195: } else if (jj_la == 0
4196: && jj_scanpos == jj_lastpos)
4197: return false;
4198: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4199: return false;
4200: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4201: return false;
4202: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4203: return false;
4204: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
4205: return false;
4206: return false;
4207: }
4208:
4209: final private boolean jj_3R_76() {
4210: if (jj_scan_token(FUNCTION_STRING_LENGTH))
4211: return true;
4212: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4213: return false;
4214: return false;
4215: }
4216:
4217: final private boolean jj_3R_75() {
4218: if (jj_scan_token(FUNCTION_SUBSTRING))
4219: return true;
4220: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4221: return false;
4222: return false;
4223: }
4224:
4225: final private boolean jj_3R_74() {
4226: if (jj_scan_token(FUNCTION_SUBSTRING_AFTER))
4227: return true;
4228: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4229: return false;
4230: return false;
4231: }
4232:
4233: final private boolean jj_3R_73() {
4234: if (jj_scan_token(FUNCTION_SUBSTRING_BEFORE))
4235: return true;
4236: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4237: return false;
4238: return false;
4239: }
4240:
4241: final private boolean jj_3R_72() {
4242: if (jj_scan_token(FUNCTION_CONTAINS))
4243: return true;
4244: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4245: return false;
4246: return false;
4247: }
4248:
4249: final private boolean jj_3R_71() {
4250: if (jj_scan_token(FUNCTION_STARTS_WITH))
4251: return true;
4252: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4253: return false;
4254: return false;
4255: }
4256:
4257: final private boolean jj_3R_70() {
4258: if (jj_scan_token(FUNCTION_CONCAT))
4259: return true;
4260: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4261: return false;
4262: return false;
4263: }
4264:
4265: final private boolean jj_3R_69() {
4266: if (jj_scan_token(FUNCTION_STRING))
4267: return true;
4268: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4269: return false;
4270: return false;
4271: }
4272:
4273: final private boolean jj_3R_68() {
4274: if (jj_scan_token(FUNCTION_NAME))
4275: return true;
4276: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4277: return false;
4278: return false;
4279: }
4280:
4281: final private boolean jj_3R_67() {
4282: if (jj_scan_token(FUNCTION_NAMESPACE_URI))
4283: return true;
4284: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4285: return false;
4286: return false;
4287: }
4288:
4289: final private boolean jj_3R_66() {
4290: if (jj_scan_token(FUNCTION_LOCAL_NAME))
4291: return true;
4292: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4293: return false;
4294: return false;
4295: }
4296:
4297: public XPathParserTokenManager token_source;
4298: SimpleCharStream jj_input_stream;
4299: public Token token, jj_nt;
4300: private Token jj_scanpos, jj_lastpos;
4301: private int jj_la;
4302: public boolean lookingAhead = false;
4303: private boolean jj_semLA;
4304: private int jj_gen;
4305: final private int[] jj_la1 = new int[39];
4306: static private int[] jj_la1_0;
4307: static private int[] jj_la1_1;
4308: static private int[] jj_la1_2;
4309: static {
4310: jj_la1_0();
4311: jj_la1_1();
4312: jj_la1_2();
4313: }
4314:
4315: private static void jj_la1_0() {
4316: jj_la1_0 = new int[] { 0xf8000000, 0x78000000, 0x0, 0x0,
4317: 0x78000000, 0xf80000c0, 0xc0, 0x40, 0xc0, 0xc0,
4318: 0xf8000000, 0xf8000000, 0x0, 0x0, 0x0, 0x0, 0x160000,
4319: 0xf8000000, 0x0, 0xf81604c0, 0x100, 0xf80000c0, 0x0,
4320: 0xc0, 0x8000000, 0x10000000, 0x1800, 0x1800, 0x1e000,
4321: 0x1e000, 0x200, 0x400, 0x60000000, 0x60000000,
4322: 0xf81604c0, 0xf8000000, 0xf8000000, 0x0, 0x80000000, };
4323: }
4324:
4325: private static void jj_la1_1() {
4326: jj_la1_1 = new int[] { 0xffff0007, 0x0, 0xffff0000, 0x0, 0x0,
4327: 0xffffffff, 0x0, 0x0, 0x0, 0x0, 0xffff0007, 0xffffffff,
4328: 0x0, 0xfff8, 0xfff8, 0x0, 0x0, 0xffff0007, 0x0,
4329: 0xffffffff, 0x0, 0xffffffff, 0x0, 0x0, 0x0, 0x0, 0x0,
4330: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffffffff,
4331: 0xffff0007, 0xffff0007, 0x0, 0x7, };
4332: }
4333:
4334: private static void jj_la1_2() {
4335: jj_la1_2 = new int[] { 0x7fff, 0x4000, 0x3fff, 0x8000, 0x4000,
4336: 0x14c7fff, 0x0, 0x0, 0x0, 0x0, 0x1007fff, 0x14c7fff,
4337: 0x100000, 0x0, 0x0, 0x400000, 0x10000, 0x7fff,
4338: 0x800000, 0x14d7fff, 0x0, 0x14c7fff, 0x100000, 0x0,
4339: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1000000,
4340: 0x1000000, 0x14d7fff, 0x1007fff, 0x1007fff, 0x8000,
4341: 0x0, };
4342: }
4343:
4344: final private JJCalls[] jj_2_rtns = new JJCalls[6];
4345: private boolean jj_rescan = false;
4346: private int jj_gc = 0;
4347:
4348: public XPathParser(java.io.InputStream stream) {
4349: jj_input_stream = new SimpleCharStream(stream, 1, 1);
4350: token_source = new XPathParserTokenManager(jj_input_stream);
4351: token = new Token();
4352: token.next = jj_nt = token_source.getNextToken();
4353: jj_gen = 0;
4354: for (int i = 0; i < 39; i++)
4355: jj_la1[i] = -1;
4356: for (int i = 0; i < jj_2_rtns.length; i++)
4357: jj_2_rtns[i] = new JJCalls();
4358: }
4359:
4360: public void ReInit(java.io.InputStream stream) {
4361: jj_input_stream.ReInit(stream, 1, 1);
4362: token_source.ReInit(jj_input_stream);
4363: token = new Token();
4364: token.next = jj_nt = token_source.getNextToken();
4365: jj_gen = 0;
4366: for (int i = 0; i < 39; i++)
4367: jj_la1[i] = -1;
4368: for (int i = 0; i < jj_2_rtns.length; i++)
4369: jj_2_rtns[i] = new JJCalls();
4370: }
4371:
4372: public XPathParser(java.io.Reader stream) {
4373: jj_input_stream = new SimpleCharStream(stream, 1, 1);
4374: token_source = new XPathParserTokenManager(jj_input_stream);
4375: token = new Token();
4376: token.next = jj_nt = token_source.getNextToken();
4377: jj_gen = 0;
4378: for (int i = 0; i < 39; i++)
4379: jj_la1[i] = -1;
4380: for (int i = 0; i < jj_2_rtns.length; i++)
4381: jj_2_rtns[i] = new JJCalls();
4382: }
4383:
4384: public void ReInit(java.io.Reader stream) {
4385: jj_input_stream.ReInit(stream, 1, 1);
4386: token_source.ReInit(jj_input_stream);
4387: token = new Token();
4388: token.next = jj_nt = token_source.getNextToken();
4389: jj_gen = 0;
4390: for (int i = 0; i < 39; i++)
4391: jj_la1[i] = -1;
4392: for (int i = 0; i < jj_2_rtns.length; i++)
4393: jj_2_rtns[i] = new JJCalls();
4394: }
4395:
4396: public XPathParser(XPathParserTokenManager tm) {
4397: token_source = tm;
4398: token = new Token();
4399: token.next = jj_nt = token_source.getNextToken();
4400: jj_gen = 0;
4401: for (int i = 0; i < 39; i++)
4402: jj_la1[i] = -1;
4403: for (int i = 0; i < jj_2_rtns.length; i++)
4404: jj_2_rtns[i] = new JJCalls();
4405: }
4406:
4407: public void ReInit(XPathParserTokenManager tm) {
4408: token_source = tm;
4409: token = new Token();
4410: token.next = jj_nt = token_source.getNextToken();
4411: jj_gen = 0;
4412: for (int i = 0; i < 39; i++)
4413: jj_la1[i] = -1;
4414: for (int i = 0; i < jj_2_rtns.length; i++)
4415: jj_2_rtns[i] = new JJCalls();
4416: }
4417:
4418: final private Token jj_consume_token(int kind)
4419: throws ParseException {
4420: Token oldToken = token;
4421: if ((token = jj_nt).next != null)
4422: jj_nt = jj_nt.next;
4423: else
4424: jj_nt = jj_nt.next = token_source.getNextToken();
4425: if (token.kind == kind) {
4426: jj_gen++;
4427: if (++jj_gc > 100) {
4428: jj_gc = 0;
4429: for (int i = 0; i < jj_2_rtns.length; i++) {
4430: JJCalls c = jj_2_rtns[i];
4431: while (c != null) {
4432: if (c.gen < jj_gen)
4433: c.first = null;
4434: c = c.next;
4435: }
4436: }
4437: }
4438: return token;
4439: }
4440: jj_nt = token;
4441: token = oldToken;
4442: jj_kind = kind;
4443: throw generateParseException();
4444: }
4445:
4446: final private boolean jj_scan_token(int kind) {
4447: if (jj_scanpos == jj_lastpos) {
4448: jj_la--;
4449: if (jj_scanpos.next == null) {
4450: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
4451: .getNextToken();
4452: } else {
4453: jj_lastpos = jj_scanpos = jj_scanpos.next;
4454: }
4455: } else {
4456: jj_scanpos = jj_scanpos.next;
4457: }
4458: if (jj_rescan) {
4459: int i = 0;
4460: Token tok = token;
4461: while (tok != null && tok != jj_scanpos) {
4462: i++;
4463: tok = tok.next;
4464: }
4465: if (tok != null)
4466: jj_add_error_token(kind, i);
4467: }
4468: return (jj_scanpos.kind != kind);
4469: }
4470:
4471: final public Token getNextToken() {
4472: if ((token = jj_nt).next != null)
4473: jj_nt = jj_nt.next;
4474: else
4475: jj_nt = jj_nt.next = token_source.getNextToken();
4476: jj_gen++;
4477: return token;
4478: }
4479:
4480: final public Token getToken(int index) {
4481: Token t = lookingAhead ? jj_scanpos : token;
4482: for (int i = 0; i < index; i++) {
4483: if (t.next != null)
4484: t = t.next;
4485: else
4486: t = t.next = token_source.getNextToken();
4487: }
4488: return t;
4489: }
4490:
4491: private java.util.Vector jj_expentries = new java.util.Vector();
4492: private int[] jj_expentry;
4493: private int jj_kind = -1;
4494: private int[] jj_lasttokens = new int[100];
4495: private int jj_endpos;
4496:
4497: private void jj_add_error_token(int kind, int pos) {
4498: if (pos >= 100) return;
4499: if (pos == jj_endpos + 1) {
4500: jj_lasttokens[jj_endpos++] = kind;
4501: } else if (jj_endpos != 0) {
4502: jj_expentry = new int[jj_endpos];
4503: for (int i = 0; i < jj_endpos; i++) {
4504: jj_expentry[i] = jj_lasttokens[i];
4505: }
4506: boolean exists = false;
4507: for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
4508: int[] oldentry = (int[])(enum.nextElement());
4509: if (oldentry.length == jj_expentry.length) {
4510: exists = true;
4511: for (int i = 0; i < jj_expentry.length; i++) {
4512: if (oldentry[i] != jj_expentry[i]) {
4513: exists = false;
4514: break;
4515: }
4516: }
4517: if (exists) break;
4518: }
4519: }
4520: if (!exists) jj_expentries.addElement(jj_expentry);
4521: if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
4522: }
4523: }
4524:
4525: public ParseException generateParseException() {
4526: jj_expentries.removeAllElements();
4527: boolean[] la1tokens = new boolean[89];
4528: for (int i = 0; i < 89; i++) {
4529: la1tokens[i] = false;
4530: }
4531: if (jj_kind >= 0) {
4532: la1tokens[jj_kind] = true;
4533: jj_kind = -1;
4534: }
4535: for (int i = 0; i < 39; i++) {
4536: if (jj_la1[i] == jj_gen) {
4537: for (int j = 0; j < 32; j++) {
4538: if ((jj_la1_0[i] & (1 << j)) != 0) {
4539: la1tokens[j] = true;
4540: }
4541: if ((jj_la1_1[i] & (1 << j)) != 0) {
4542: la1tokens[32 + j] = true;
4543: }
4544: if ((jj_la1_2[i] & (1 << j)) != 0) {
4545: la1tokens[64 + j] = true;
4546: }
4547: }
4548: }
4549: }
4550: for (int i = 0; i < 89; i++) {
4551: if (la1tokens[i]) {
4552: jj_expentry = new int[1];
4553: jj_expentry[0] = i;
4554: jj_expentries.addElement(jj_expentry);
4555: }
4556: }
4557: jj_endpos = 0;
4558: jj_rescan_token();
4559: jj_add_error_token(0, 0);
4560: int[][] exptokseq = new int[jj_expentries.size()][];
4561: for (int i = 0; i < jj_expentries.size(); i++) {
4562: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
4563: }
4564: return new ParseException(token, exptokseq, tokenImage);
4565: }
4566:
4567: final public void enable_tracing() {
4568: }
4569:
4570: final public void disable_tracing() {
4571: }
4572:
4573: final private void jj_rescan_token() {
4574: jj_rescan = true;
4575: for (int i = 0; i < 6; i++) {
4576: JJCalls p = jj_2_rtns[i];
4577: do {
4578: if (p.gen > jj_gen) {
4579: jj_la = p.arg;
4580: jj_lastpos = jj_scanpos = p.first;
4581: switch (i) {
4582: case 0:
4583: jj_3_1();
4584: break;
4585: case 1:
4586: jj_3_2();
4587: break;
4588: case 2:
4589: jj_3_3();
4590: break;
4591: case 3:
4592: jj_3_4();
4593: break;
4594: case 4:
4595: jj_3_5();
4596: break;
4597: case 5:
4598: jj_3_6();
4599: break;
4600: }
4601: }
4602: p = p.next;
4603: } while (p != null);
4604: }
4605: jj_rescan = false;
4606: }
4607:
4608: final private void jj_save(int index, int xla) {
4609: JJCalls p = jj_2_rtns[index];
4610: while (p.gen > jj_gen) {
4611: if (p.next == null) {
4612: p = p.next = new JJCalls();
4613: break;
4614: }
4615: p = p.next;
4616: }
4617: p.gen = jj_gen + xla - jj_la;
4618: p.first = token;
4619: p.arg = xla;
4620: }
4621:
4622: static final class JJCalls {
4623: int gen;
4624: Token first;
4625: int arg;
4626: JJCalls next;
4627: }
4628:
4629: }
|