0001: /* Generated By:JJTree&JavaCC: Do not edit this line. SyntaxTreeBuilder.java */
0002: package org.openrdf.query.parser.sparql.ast;
0003:
0004: import java.io.StringReader;
0005:
0006: import org.openrdf.model.URI;
0007: import org.openrdf.model.vocabulary.RDF;
0008: import org.openrdf.model.vocabulary.XMLSchema;
0009: import org.openrdf.query.algebra.Compare.CompareOp;
0010: import org.openrdf.query.algebra.MathExpr.MathOp;
0011:
0012: public class SyntaxTreeBuilder/*@bgen(jjtree)*/implements
0013: SyntaxTreeBuilderTreeConstants, SyntaxTreeBuilderConstants {/*@bgen(jjtree)*/
0014: protected JJTSyntaxTreeBuilderState jjtree = new JJTSyntaxTreeBuilderState();
0015:
0016: /**
0017: * Parses the supplied SPARQL query and builds a syntax tree from it.
0018: *
0019: * @param query A SPARQL query string.
0020: * @return The root of the syntax tree.
0021: * @throws TokenMgrError If the query was syntactically incorrect.
0022: * @throws ParseException If the query was syntactically incorrect.
0023: */
0024: public static ASTQueryContainer parseQuery(String query)
0025: throws TokenMgrError, ParseException {
0026: SyntaxTreeBuilder stb = new SyntaxTreeBuilder(new StringReader(
0027: query));
0028: return stb.QueryContainer();
0029: }
0030:
0031: /**
0032: * Trims <tt>n</tt> character from the start and end of the supplied string.
0033: */
0034: private static String _trimString(String s, int n) {
0035: if (s.length() >= 2) {
0036: s = s.substring(n, s.length() - n);
0037: }
0038: return s;
0039: }
0040:
0041: //
0042: // grammar
0043: //
0044: final public ASTQueryContainer QueryContainer()
0045: throws ParseException {
0046: /*@bgen(jjtree) QueryContainer */
0047: ASTQueryContainer jjtn000 = new ASTQueryContainer(
0048: JJTQUERYCONTAINER);
0049: boolean jjtc000 = true;
0050: jjtree.openNodeScope(jjtn000);
0051: try {
0052: Prolog();
0053: Query();
0054: jj_consume_token(0);
0055: jjtree.closeNodeScope(jjtn000, true);
0056: jjtc000 = false;
0057: {
0058: if (true)
0059: return jjtn000;
0060: }
0061: } catch (Throwable jjte000) {
0062: if (jjtc000) {
0063: jjtree.clearNodeScope(jjtn000);
0064: jjtc000 = false;
0065: } else {
0066: jjtree.popNode();
0067: }
0068: if (jjte000 instanceof RuntimeException) {
0069: {
0070: if (true)
0071: throw (RuntimeException) jjte000;
0072: }
0073: }
0074: if (jjte000 instanceof ParseException) {
0075: {
0076: if (true)
0077: throw (ParseException) jjte000;
0078: }
0079: }
0080: {
0081: if (true)
0082: throw (Error) jjte000;
0083: }
0084: } finally {
0085: if (jjtc000) {
0086: jjtree.closeNodeScope(jjtn000, true);
0087: }
0088: }
0089: throw new Error("Missing return statement in function");
0090: }
0091:
0092: final public void Prolog() throws ParseException {
0093: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0094: case BASE:
0095: BaseDecl();
0096: break;
0097: default:
0098: jj_la1[0] = jj_gen;
0099: ;
0100: }
0101: label_1: while (true) {
0102: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0103: case PREFIX:
0104: ;
0105: break;
0106: default:
0107: jj_la1[1] = jj_gen;
0108: break label_1;
0109: }
0110: PrefixDecl();
0111: }
0112: }
0113:
0114: final public void BaseDecl() throws ParseException {
0115: /*@bgen(jjtree) BaseDecl */
0116: ASTBaseDecl jjtn000 = new ASTBaseDecl(JJTBASEDECL);
0117: boolean jjtc000 = true;
0118: jjtree.openNodeScope(jjtn000);
0119: Token t;
0120: try {
0121: jj_consume_token(BASE);
0122: t = jj_consume_token(Q_IRI_REF);
0123: jjtree.closeNodeScope(jjtn000, true);
0124: jjtc000 = false;
0125: jjtn000.setIRI(_trimString(t.image, 1));
0126: } finally {
0127: if (jjtc000) {
0128: jjtree.closeNodeScope(jjtn000, true);
0129: }
0130: }
0131: }
0132:
0133: final public void PrefixDecl() throws ParseException {
0134: /*@bgen(jjtree) PrefixDecl */
0135: ASTPrefixDecl jjtn000 = new ASTPrefixDecl(JJTPREFIXDECL);
0136: boolean jjtc000 = true;
0137: jjtree.openNodeScope(jjtn000);
0138: Token prefix;
0139: try {
0140: jj_consume_token(PREFIX);
0141: prefix = jj_consume_token(PNAME_NS);
0142: IRI();
0143: jjtree.closeNodeScope(jjtn000, true);
0144: jjtc000 = false;
0145: // Remove trailing colon from prefix
0146: String prefixStr = prefix.image;
0147: prefixStr = prefixStr.substring(0, prefixStr.length() - 1);
0148:
0149: jjtn000.setPrefix(prefixStr);
0150: } catch (Throwable jjte000) {
0151: if (jjtc000) {
0152: jjtree.clearNodeScope(jjtn000);
0153: jjtc000 = false;
0154: } else {
0155: jjtree.popNode();
0156: }
0157: if (jjte000 instanceof RuntimeException) {
0158: {
0159: if (true)
0160: throw (RuntimeException) jjte000;
0161: }
0162: }
0163: if (jjte000 instanceof ParseException) {
0164: {
0165: if (true)
0166: throw (ParseException) jjte000;
0167: }
0168: }
0169: {
0170: if (true)
0171: throw (Error) jjte000;
0172: }
0173: } finally {
0174: if (jjtc000) {
0175: jjtree.closeNodeScope(jjtn000, true);
0176: }
0177: }
0178: }
0179:
0180: final public void Query() throws ParseException {
0181: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0182: case SELECT:
0183: SelectQuery();
0184: break;
0185: case CONSTRUCT:
0186: ConstructQuery();
0187: break;
0188: case DESCRIBE:
0189: DescribeQuery();
0190: break;
0191: case ASK:
0192: AskQuery();
0193: break;
0194: default:
0195: jj_la1[2] = jj_gen;
0196: jj_consume_token(-1);
0197: throw new ParseException();
0198: }
0199: }
0200:
0201: final public void SelectQuery() throws ParseException {
0202: /*@bgen(jjtree) SelectQuery */
0203: ASTSelectQuery jjtn000 = new ASTSelectQuery(JJTSELECTQUERY);
0204: boolean jjtc000 = true;
0205: jjtree.openNodeScope(jjtn000);
0206: try {
0207: Select();
0208: label_2: while (true) {
0209: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0210: case FROM:
0211: ;
0212: break;
0213: default:
0214: jj_la1[3] = jj_gen;
0215: break label_2;
0216: }
0217: DatasetClause();
0218: }
0219: WhereClause();
0220: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0221: case ORDER:
0222: OrderClause();
0223: break;
0224: default:
0225: jj_la1[4] = jj_gen;
0226: ;
0227: }
0228: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0229: case LIMIT:
0230: case OFFSET:
0231: LimitOffsetClauses();
0232: break;
0233: default:
0234: jj_la1[5] = jj_gen;
0235: ;
0236: }
0237: } catch (Throwable jjte000) {
0238: if (jjtc000) {
0239: jjtree.clearNodeScope(jjtn000);
0240: jjtc000 = false;
0241: } else {
0242: jjtree.popNode();
0243: }
0244: if (jjte000 instanceof RuntimeException) {
0245: {
0246: if (true)
0247: throw (RuntimeException) jjte000;
0248: }
0249: }
0250: if (jjte000 instanceof ParseException) {
0251: {
0252: if (true)
0253: throw (ParseException) jjte000;
0254: }
0255: }
0256: {
0257: if (true)
0258: throw (Error) jjte000;
0259: }
0260: } finally {
0261: if (jjtc000) {
0262: jjtree.closeNodeScope(jjtn000, true);
0263: }
0264: }
0265: }
0266:
0267: final public void Select() throws ParseException {
0268: /*@bgen(jjtree) Select */
0269: ASTSelect jjtn000 = new ASTSelect(JJTSELECT);
0270: boolean jjtc000 = true;
0271: jjtree.openNodeScope(jjtn000);
0272: try {
0273: jj_consume_token(SELECT);
0274: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0275: case DISTINCT:
0276: case REDUCED:
0277: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0278: case DISTINCT:
0279: jj_consume_token(DISTINCT);
0280: jjtn000.setDistinct(true);
0281: break;
0282: case REDUCED:
0283: jj_consume_token(REDUCED);
0284: jjtn000.setReduced(true);
0285: break;
0286: default:
0287: jj_la1[6] = jj_gen;
0288: jj_consume_token(-1);
0289: throw new ParseException();
0290: }
0291: break;
0292: default:
0293: jj_la1[7] = jj_gen;
0294: ;
0295: }
0296: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0297: case STAR:
0298: jj_consume_token(STAR);
0299: jjtree.closeNodeScope(jjtn000, true);
0300: jjtc000 = false;
0301: jjtn000.setWildcard(true);
0302: break;
0303: case VAR1:
0304: case VAR2:
0305: label_3: while (true) {
0306: Var();
0307: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0308: case VAR1:
0309: case VAR2:
0310: ;
0311: break;
0312: default:
0313: jj_la1[8] = jj_gen;
0314: break label_3;
0315: }
0316: }
0317: break;
0318: default:
0319: jj_la1[9] = jj_gen;
0320: jj_consume_token(-1);
0321: throw new ParseException();
0322: }
0323: } catch (Throwable jjte000) {
0324: if (jjtc000) {
0325: jjtree.clearNodeScope(jjtn000);
0326: jjtc000 = false;
0327: } else {
0328: jjtree.popNode();
0329: }
0330: if (jjte000 instanceof RuntimeException) {
0331: {
0332: if (true)
0333: throw (RuntimeException) jjte000;
0334: }
0335: }
0336: if (jjte000 instanceof ParseException) {
0337: {
0338: if (true)
0339: throw (ParseException) jjte000;
0340: }
0341: }
0342: {
0343: if (true)
0344: throw (Error) jjte000;
0345: }
0346: } finally {
0347: if (jjtc000) {
0348: jjtree.closeNodeScope(jjtn000, true);
0349: }
0350: }
0351: }
0352:
0353: final public void ConstructQuery() throws ParseException {
0354: /*@bgen(jjtree) ConstructQuery */
0355: ASTConstructQuery jjtn000 = new ASTConstructQuery(
0356: JJTCONSTRUCTQUERY);
0357: boolean jjtc000 = true;
0358: jjtree.openNodeScope(jjtn000);
0359: try {
0360: Construct();
0361: label_4: while (true) {
0362: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0363: case FROM:
0364: ;
0365: break;
0366: default:
0367: jj_la1[10] = jj_gen;
0368: break label_4;
0369: }
0370: DatasetClause();
0371: }
0372: WhereClause();
0373: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0374: case ORDER:
0375: OrderClause();
0376: break;
0377: default:
0378: jj_la1[11] = jj_gen;
0379: ;
0380: }
0381: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0382: case LIMIT:
0383: case OFFSET:
0384: LimitOffsetClauses();
0385: break;
0386: default:
0387: jj_la1[12] = jj_gen;
0388: ;
0389: }
0390: } catch (Throwable jjte000) {
0391: if (jjtc000) {
0392: jjtree.clearNodeScope(jjtn000);
0393: jjtc000 = false;
0394: } else {
0395: jjtree.popNode();
0396: }
0397: if (jjte000 instanceof RuntimeException) {
0398: {
0399: if (true)
0400: throw (RuntimeException) jjte000;
0401: }
0402: }
0403: if (jjte000 instanceof ParseException) {
0404: {
0405: if (true)
0406: throw (ParseException) jjte000;
0407: }
0408: }
0409: {
0410: if (true)
0411: throw (Error) jjte000;
0412: }
0413: } finally {
0414: if (jjtc000) {
0415: jjtree.closeNodeScope(jjtn000, true);
0416: }
0417: }
0418: }
0419:
0420: final public void Construct() throws ParseException {
0421: /*@bgen(jjtree) Construct */
0422: ASTConstruct jjtn000 = new ASTConstruct(JJTCONSTRUCT);
0423: boolean jjtc000 = true;
0424: jjtree.openNodeScope(jjtn000);
0425: try {
0426: jj_consume_token(CONSTRUCT);
0427: jj_consume_token(LBRACE);
0428: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0429: case LPAREN:
0430: case LBRACK:
0431: case NIL:
0432: case ANON:
0433: case TRUE:
0434: case FALSE:
0435: case Q_IRI_REF:
0436: case PNAME_NS:
0437: case PNAME_LN:
0438: case BLANK_NODE_LABEL:
0439: case VAR1:
0440: case VAR2:
0441: case INTEGER:
0442: case INTEGER_POSITIVE:
0443: case INTEGER_NEGATIVE:
0444: case DECIMAL:
0445: case DECIMAL_POSITIVE:
0446: case DECIMAL_NEGATIVE:
0447: case DOUBLE:
0448: case DOUBLE_POSITIVE:
0449: case DOUBLE_NEGATIVE:
0450: case STRING_LITERAL1:
0451: case STRING_LITERAL2:
0452: case STRING_LITERAL_LONG1:
0453: case STRING_LITERAL_LONG2:
0454: TriplesBlock();
0455: break;
0456: default:
0457: jj_la1[13] = jj_gen;
0458: ;
0459: }
0460: jj_consume_token(RBRACE);
0461: } catch (Throwable jjte000) {
0462: if (jjtc000) {
0463: jjtree.clearNodeScope(jjtn000);
0464: jjtc000 = false;
0465: } else {
0466: jjtree.popNode();
0467: }
0468: if (jjte000 instanceof RuntimeException) {
0469: {
0470: if (true)
0471: throw (RuntimeException) jjte000;
0472: }
0473: }
0474: if (jjte000 instanceof ParseException) {
0475: {
0476: if (true)
0477: throw (ParseException) jjte000;
0478: }
0479: }
0480: {
0481: if (true)
0482: throw (Error) jjte000;
0483: }
0484: } finally {
0485: if (jjtc000) {
0486: jjtree.closeNodeScope(jjtn000, true);
0487: }
0488: }
0489: }
0490:
0491: final public void DescribeQuery() throws ParseException {
0492: /*@bgen(jjtree) DescribeQuery */
0493: ASTDescribeQuery jjtn000 = new ASTDescribeQuery(
0494: JJTDESCRIBEQUERY);
0495: boolean jjtc000 = true;
0496: jjtree.openNodeScope(jjtn000);
0497: try {
0498: Describe();
0499: label_5: while (true) {
0500: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0501: case FROM:
0502: ;
0503: break;
0504: default:
0505: jj_la1[14] = jj_gen;
0506: break label_5;
0507: }
0508: DatasetClause();
0509: }
0510: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0511: case LBRACE:
0512: case WHERE:
0513: WhereClause();
0514: break;
0515: default:
0516: jj_la1[15] = jj_gen;
0517: ;
0518: }
0519: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0520: case ORDER:
0521: OrderClause();
0522: break;
0523: default:
0524: jj_la1[16] = jj_gen;
0525: ;
0526: }
0527: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0528: case LIMIT:
0529: case OFFSET:
0530: LimitOffsetClauses();
0531: break;
0532: default:
0533: jj_la1[17] = jj_gen;
0534: ;
0535: }
0536: } catch (Throwable jjte000) {
0537: if (jjtc000) {
0538: jjtree.clearNodeScope(jjtn000);
0539: jjtc000 = false;
0540: } else {
0541: jjtree.popNode();
0542: }
0543: if (jjte000 instanceof RuntimeException) {
0544: {
0545: if (true)
0546: throw (RuntimeException) jjte000;
0547: }
0548: }
0549: if (jjte000 instanceof ParseException) {
0550: {
0551: if (true)
0552: throw (ParseException) jjte000;
0553: }
0554: }
0555: {
0556: if (true)
0557: throw (Error) jjte000;
0558: }
0559: } finally {
0560: if (jjtc000) {
0561: jjtree.closeNodeScope(jjtn000, true);
0562: }
0563: }
0564: }
0565:
0566: final public void Describe() throws ParseException {
0567: /*@bgen(jjtree) Describe */
0568: ASTDescribe jjtn000 = new ASTDescribe(JJTDESCRIBE);
0569: boolean jjtc000 = true;
0570: jjtree.openNodeScope(jjtn000);
0571: try {
0572: jj_consume_token(DESCRIBE);
0573: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0574: case STAR:
0575: jj_consume_token(STAR);
0576: jjtree.closeNodeScope(jjtn000, true);
0577: jjtc000 = false;
0578: jjtn000.setWildcard(true);
0579: break;
0580: case Q_IRI_REF:
0581: case PNAME_NS:
0582: case PNAME_LN:
0583: case VAR1:
0584: case VAR2:
0585: label_6: while (true) {
0586: VarOrIRIref();
0587: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0588: case Q_IRI_REF:
0589: case PNAME_NS:
0590: case PNAME_LN:
0591: case VAR1:
0592: case VAR2:
0593: ;
0594: break;
0595: default:
0596: jj_la1[18] = jj_gen;
0597: break label_6;
0598: }
0599: }
0600: break;
0601: default:
0602: jj_la1[19] = jj_gen;
0603: jj_consume_token(-1);
0604: throw new ParseException();
0605: }
0606: } catch (Throwable jjte000) {
0607: if (jjtc000) {
0608: jjtree.clearNodeScope(jjtn000);
0609: jjtc000 = false;
0610: } else {
0611: jjtree.popNode();
0612: }
0613: if (jjte000 instanceof RuntimeException) {
0614: {
0615: if (true)
0616: throw (RuntimeException) jjte000;
0617: }
0618: }
0619: if (jjte000 instanceof ParseException) {
0620: {
0621: if (true)
0622: throw (ParseException) jjte000;
0623: }
0624: }
0625: {
0626: if (true)
0627: throw (Error) jjte000;
0628: }
0629: } finally {
0630: if (jjtc000) {
0631: jjtree.closeNodeScope(jjtn000, true);
0632: }
0633: }
0634: }
0635:
0636: final public void AskQuery() throws ParseException {
0637: /*@bgen(jjtree) AskQuery */
0638: ASTAskQuery jjtn000 = new ASTAskQuery(JJTASKQUERY);
0639: boolean jjtc000 = true;
0640: jjtree.openNodeScope(jjtn000);
0641: try {
0642: jj_consume_token(ASK);
0643: label_7: while (true) {
0644: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0645: case FROM:
0646: ;
0647: break;
0648: default:
0649: jj_la1[20] = jj_gen;
0650: break label_7;
0651: }
0652: DatasetClause();
0653: }
0654: WhereClause();
0655: } catch (Throwable jjte000) {
0656: if (jjtc000) {
0657: jjtree.clearNodeScope(jjtn000);
0658: jjtc000 = false;
0659: } else {
0660: jjtree.popNode();
0661: }
0662: if (jjte000 instanceof RuntimeException) {
0663: {
0664: if (true)
0665: throw (RuntimeException) jjte000;
0666: }
0667: }
0668: if (jjte000 instanceof ParseException) {
0669: {
0670: if (true)
0671: throw (ParseException) jjte000;
0672: }
0673: }
0674: {
0675: if (true)
0676: throw (Error) jjte000;
0677: }
0678: } finally {
0679: if (jjtc000) {
0680: jjtree.closeNodeScope(jjtn000, true);
0681: }
0682: }
0683: }
0684:
0685: final public void DatasetClause() throws ParseException {
0686: /*@bgen(jjtree) DatasetClause */
0687: ASTDatasetClause jjtn000 = new ASTDatasetClause(
0688: JJTDATASETCLAUSE);
0689: boolean jjtc000 = true;
0690: jjtree.openNodeScope(jjtn000);
0691: try {
0692: jj_consume_token(FROM);
0693: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0694: case NAMED:
0695: jj_consume_token(NAMED);
0696: jjtn000.setNamed(true);
0697: break;
0698: default:
0699: jj_la1[21] = jj_gen;
0700: ;
0701: }
0702: IRIref();
0703: } catch (Throwable jjte000) {
0704: if (jjtc000) {
0705: jjtree.clearNodeScope(jjtn000);
0706: jjtc000 = false;
0707: } else {
0708: jjtree.popNode();
0709: }
0710: if (jjte000 instanceof RuntimeException) {
0711: {
0712: if (true)
0713: throw (RuntimeException) jjte000;
0714: }
0715: }
0716: if (jjte000 instanceof ParseException) {
0717: {
0718: if (true)
0719: throw (ParseException) jjte000;
0720: }
0721: }
0722: {
0723: if (true)
0724: throw (Error) jjte000;
0725: }
0726: } finally {
0727: if (jjtc000) {
0728: jjtree.closeNodeScope(jjtn000, true);
0729: }
0730: }
0731: }
0732:
0733: final public void WhereClause() throws ParseException {
0734: /*@bgen(jjtree) WhereClause */
0735: ASTWhereClause jjtn000 = new ASTWhereClause(JJTWHERECLAUSE);
0736: boolean jjtc000 = true;
0737: jjtree.openNodeScope(jjtn000);
0738: try {
0739: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0740: case WHERE:
0741: jj_consume_token(WHERE);
0742: break;
0743: default:
0744: jj_la1[22] = jj_gen;
0745: ;
0746: }
0747: GroupGraphPattern();
0748: } catch (Throwable jjte000) {
0749: if (jjtc000) {
0750: jjtree.clearNodeScope(jjtn000);
0751: jjtc000 = false;
0752: } else {
0753: jjtree.popNode();
0754: }
0755: if (jjte000 instanceof RuntimeException) {
0756: {
0757: if (true)
0758: throw (RuntimeException) jjte000;
0759: }
0760: }
0761: if (jjte000 instanceof ParseException) {
0762: {
0763: if (true)
0764: throw (ParseException) jjte000;
0765: }
0766: }
0767: {
0768: if (true)
0769: throw (Error) jjte000;
0770: }
0771: } finally {
0772: if (jjtc000) {
0773: jjtree.closeNodeScope(jjtn000, true);
0774: }
0775: }
0776: }
0777:
0778: final public void OrderClause() throws ParseException {
0779: /*@bgen(jjtree) OrderClause */
0780: ASTOrderClause jjtn000 = new ASTOrderClause(JJTORDERCLAUSE);
0781: boolean jjtc000 = true;
0782: jjtree.openNodeScope(jjtn000);
0783: try {
0784: jj_consume_token(ORDER);
0785: jj_consume_token(BY);
0786: label_8: while (true) {
0787: OrderCondition();
0788: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0789: case LPAREN:
0790: case ASC:
0791: case DESC:
0792: case STR:
0793: case LANG:
0794: case LANGMATCHES:
0795: case DATATYPE:
0796: case BOUND:
0797: case SAMETERM:
0798: case IS_IRI:
0799: case IS_BLANK:
0800: case IS_LITERAL:
0801: case REGEX:
0802: case Q_IRI_REF:
0803: case PNAME_NS:
0804: case PNAME_LN:
0805: case VAR1:
0806: case VAR2:
0807: ;
0808: break;
0809: default:
0810: jj_la1[23] = jj_gen;
0811: break label_8;
0812: }
0813: }
0814: } catch (Throwable jjte000) {
0815: if (jjtc000) {
0816: jjtree.clearNodeScope(jjtn000);
0817: jjtc000 = false;
0818: } else {
0819: jjtree.popNode();
0820: }
0821: if (jjte000 instanceof RuntimeException) {
0822: {
0823: if (true)
0824: throw (RuntimeException) jjte000;
0825: }
0826: }
0827: if (jjte000 instanceof ParseException) {
0828: {
0829: if (true)
0830: throw (ParseException) jjte000;
0831: }
0832: }
0833: {
0834: if (true)
0835: throw (Error) jjte000;
0836: }
0837: } finally {
0838: if (jjtc000) {
0839: jjtree.closeNodeScope(jjtn000, true);
0840: }
0841: }
0842: }
0843:
0844: final public void OrderCondition() throws ParseException {
0845: /*@bgen(jjtree) OrderCondition */
0846: ASTOrderCondition jjtn000 = new ASTOrderCondition(
0847: JJTORDERCONDITION);
0848: boolean jjtc000 = true;
0849: jjtree.openNodeScope(jjtn000);
0850: try {
0851: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0852: case LPAREN:
0853: case ASC:
0854: case DESC:
0855: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0856: case ASC:
0857: case DESC:
0858: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0859: case ASC:
0860: jj_consume_token(ASC);
0861: break;
0862: case DESC:
0863: jj_consume_token(DESC);
0864: jjtn000.setAscending(false);
0865: break;
0866: default:
0867: jj_la1[24] = jj_gen;
0868: jj_consume_token(-1);
0869: throw new ParseException();
0870: }
0871: break;
0872: default:
0873: jj_la1[25] = jj_gen;
0874: ;
0875: }
0876: BrackettedExpression();
0877: break;
0878: case Q_IRI_REF:
0879: case PNAME_NS:
0880: case PNAME_LN:
0881: FunctionCall();
0882: break;
0883: case STR:
0884: case LANG:
0885: case LANGMATCHES:
0886: case DATATYPE:
0887: case BOUND:
0888: case SAMETERM:
0889: case IS_IRI:
0890: case IS_BLANK:
0891: case IS_LITERAL:
0892: case REGEX:
0893: BuiltInCall();
0894: break;
0895: case VAR1:
0896: case VAR2:
0897: Var();
0898: break;
0899: default:
0900: jj_la1[26] = jj_gen;
0901: jj_consume_token(-1);
0902: throw new ParseException();
0903: }
0904: } catch (Throwable jjte000) {
0905: if (jjtc000) {
0906: jjtree.clearNodeScope(jjtn000);
0907: jjtc000 = false;
0908: } else {
0909: jjtree.popNode();
0910: }
0911: if (jjte000 instanceof RuntimeException) {
0912: {
0913: if (true)
0914: throw (RuntimeException) jjte000;
0915: }
0916: }
0917: if (jjte000 instanceof ParseException) {
0918: {
0919: if (true)
0920: throw (ParseException) jjte000;
0921: }
0922: }
0923: {
0924: if (true)
0925: throw (Error) jjte000;
0926: }
0927: } finally {
0928: if (jjtc000) {
0929: jjtree.closeNodeScope(jjtn000, true);
0930: }
0931: }
0932: }
0933:
0934: final public void LimitOffsetClauses() throws ParseException {
0935: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0936: case LIMIT:
0937: Limit();
0938: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0939: case OFFSET:
0940: Offset();
0941: break;
0942: default:
0943: jj_la1[27] = jj_gen;
0944: ;
0945: }
0946: break;
0947: case OFFSET:
0948: Offset();
0949: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0950: case LIMIT:
0951: Limit();
0952: break;
0953: default:
0954: jj_la1[28] = jj_gen;
0955: ;
0956: }
0957: break;
0958: default:
0959: jj_la1[29] = jj_gen;
0960: jj_consume_token(-1);
0961: throw new ParseException();
0962: }
0963: }
0964:
0965: final public void Limit() throws ParseException {
0966: /*@bgen(jjtree) Limit */
0967: ASTLimit jjtn000 = new ASTLimit(JJTLIMIT);
0968: boolean jjtc000 = true;
0969: jjtree.openNodeScope(jjtn000);
0970: Token t;
0971: try {
0972: jj_consume_token(LIMIT);
0973: t = jj_consume_token(INTEGER);
0974: jjtree.closeNodeScope(jjtn000, true);
0975: jjtc000 = false;
0976: jjtn000.setValue(Integer.parseInt(t.image));
0977: } finally {
0978: if (jjtc000) {
0979: jjtree.closeNodeScope(jjtn000, true);
0980: }
0981: }
0982: }
0983:
0984: final public void Offset() throws ParseException {
0985: /*@bgen(jjtree) Offset */
0986: ASTOffset jjtn000 = new ASTOffset(JJTOFFSET);
0987: boolean jjtc000 = true;
0988: jjtree.openNodeScope(jjtn000);
0989: Token t;
0990: try {
0991: jj_consume_token(OFFSET);
0992: t = jj_consume_token(INTEGER);
0993: jjtree.closeNodeScope(jjtn000, true);
0994: jjtc000 = false;
0995: jjtn000.setValue(Integer.parseInt(t.image));
0996: } finally {
0997: if (jjtc000) {
0998: jjtree.closeNodeScope(jjtn000, true);
0999: }
1000: }
1001: }
1002:
1003: final public void GroupGraphPattern() throws ParseException {
1004: /*@bgen(jjtree) GraphPatternGroup */
1005: ASTGraphPatternGroup jjtn000 = new ASTGraphPatternGroup(
1006: JJTGRAPHPATTERNGROUP);
1007: boolean jjtc000 = true;
1008: jjtree.openNodeScope(jjtn000);
1009: try {
1010: jj_consume_token(LBRACE);
1011: GraphPattern();
1012: jj_consume_token(RBRACE);
1013: } catch (Throwable jjte000) {
1014: if (jjtc000) {
1015: jjtree.clearNodeScope(jjtn000);
1016: jjtc000 = false;
1017: } else {
1018: jjtree.popNode();
1019: }
1020: if (jjte000 instanceof RuntimeException) {
1021: {
1022: if (true)
1023: throw (RuntimeException) jjte000;
1024: }
1025: }
1026: if (jjte000 instanceof ParseException) {
1027: {
1028: if (true)
1029: throw (ParseException) jjte000;
1030: }
1031: }
1032: {
1033: if (true)
1034: throw (Error) jjte000;
1035: }
1036: } finally {
1037: if (jjtc000) {
1038: jjtree.closeNodeScope(jjtn000, true);
1039: }
1040: }
1041: }
1042:
1043: final public void GraphPattern() throws ParseException {
1044: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1045: case LPAREN:
1046: case LBRACK:
1047: case NIL:
1048: case ANON:
1049: case FILTER:
1050: case TRUE:
1051: case FALSE:
1052: case Q_IRI_REF:
1053: case PNAME_NS:
1054: case PNAME_LN:
1055: case BLANK_NODE_LABEL:
1056: case VAR1:
1057: case VAR2:
1058: case INTEGER:
1059: case INTEGER_POSITIVE:
1060: case INTEGER_NEGATIVE:
1061: case DECIMAL:
1062: case DECIMAL_POSITIVE:
1063: case DECIMAL_NEGATIVE:
1064: case DOUBLE:
1065: case DOUBLE_POSITIVE:
1066: case DOUBLE_NEGATIVE:
1067: case STRING_LITERAL1:
1068: case STRING_LITERAL2:
1069: case STRING_LITERAL_LONG1:
1070: case STRING_LITERAL_LONG2:
1071: BasicGraphPattern();
1072: break;
1073: default:
1074: jj_la1[30] = jj_gen;
1075: ;
1076: }
1077: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1078: case LBRACE:
1079: case OPTIONAL:
1080: case GRAPH:
1081: GraphPatternNotTriples();
1082: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1083: case DOT:
1084: jj_consume_token(DOT);
1085: break;
1086: default:
1087: jj_la1[31] = jj_gen;
1088: ;
1089: }
1090: GraphPattern();
1091: break;
1092: default:
1093: jj_la1[32] = jj_gen;
1094: ;
1095: }
1096: }
1097:
1098: final public void BasicGraphPattern() throws ParseException {
1099: /*@bgen(jjtree) BasicGraphPattern */
1100: ASTBasicGraphPattern jjtn000 = new ASTBasicGraphPattern(
1101: JJTBASICGRAPHPATTERN);
1102: boolean jjtc000 = true;
1103: jjtree.openNodeScope(jjtn000);
1104: try {
1105: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1106: case LPAREN:
1107: case LBRACK:
1108: case NIL:
1109: case ANON:
1110: case TRUE:
1111: case FALSE:
1112: case Q_IRI_REF:
1113: case PNAME_NS:
1114: case PNAME_LN:
1115: case BLANK_NODE_LABEL:
1116: case VAR1:
1117: case VAR2:
1118: case INTEGER:
1119: case INTEGER_POSITIVE:
1120: case INTEGER_NEGATIVE:
1121: case DECIMAL:
1122: case DECIMAL_POSITIVE:
1123: case DECIMAL_NEGATIVE:
1124: case DOUBLE:
1125: case DOUBLE_POSITIVE:
1126: case DOUBLE_NEGATIVE:
1127: case STRING_LITERAL1:
1128: case STRING_LITERAL2:
1129: case STRING_LITERAL_LONG1:
1130: case STRING_LITERAL_LONG2:
1131: TriplesBlock();
1132: label_9: while (true) {
1133: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1134: case FILTER:
1135: ;
1136: break;
1137: default:
1138: jj_la1[33] = jj_gen;
1139: break label_9;
1140: }
1141: Filter();
1142: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1143: case DOT:
1144: jj_consume_token(DOT);
1145: break;
1146: default:
1147: jj_la1[34] = jj_gen;
1148: ;
1149: }
1150: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1151: case LPAREN:
1152: case LBRACK:
1153: case NIL:
1154: case ANON:
1155: case TRUE:
1156: case FALSE:
1157: case Q_IRI_REF:
1158: case PNAME_NS:
1159: case PNAME_LN:
1160: case BLANK_NODE_LABEL:
1161: case VAR1:
1162: case VAR2:
1163: case INTEGER:
1164: case INTEGER_POSITIVE:
1165: case INTEGER_NEGATIVE:
1166: case DECIMAL:
1167: case DECIMAL_POSITIVE:
1168: case DECIMAL_NEGATIVE:
1169: case DOUBLE:
1170: case DOUBLE_POSITIVE:
1171: case DOUBLE_NEGATIVE:
1172: case STRING_LITERAL1:
1173: case STRING_LITERAL2:
1174: case STRING_LITERAL_LONG1:
1175: case STRING_LITERAL_LONG2:
1176: TriplesBlock();
1177: break;
1178: default:
1179: jj_la1[35] = jj_gen;
1180: ;
1181: }
1182: }
1183: break;
1184: case FILTER:
1185: label_10: while (true) {
1186: Filter();
1187: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1188: case DOT:
1189: jj_consume_token(DOT);
1190: break;
1191: default:
1192: jj_la1[36] = jj_gen;
1193: ;
1194: }
1195: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1196: case LPAREN:
1197: case LBRACK:
1198: case NIL:
1199: case ANON:
1200: case TRUE:
1201: case FALSE:
1202: case Q_IRI_REF:
1203: case PNAME_NS:
1204: case PNAME_LN:
1205: case BLANK_NODE_LABEL:
1206: case VAR1:
1207: case VAR2:
1208: case INTEGER:
1209: case INTEGER_POSITIVE:
1210: case INTEGER_NEGATIVE:
1211: case DECIMAL:
1212: case DECIMAL_POSITIVE:
1213: case DECIMAL_NEGATIVE:
1214: case DOUBLE:
1215: case DOUBLE_POSITIVE:
1216: case DOUBLE_NEGATIVE:
1217: case STRING_LITERAL1:
1218: case STRING_LITERAL2:
1219: case STRING_LITERAL_LONG1:
1220: case STRING_LITERAL_LONG2:
1221: TriplesBlock();
1222: break;
1223: default:
1224: jj_la1[37] = jj_gen;
1225: ;
1226: }
1227: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1228: case FILTER:
1229: ;
1230: break;
1231: default:
1232: jj_la1[38] = jj_gen;
1233: break label_10;
1234: }
1235: }
1236: break;
1237: default:
1238: jj_la1[39] = jj_gen;
1239: jj_consume_token(-1);
1240: throw new ParseException();
1241: }
1242: } catch (Throwable jjte000) {
1243: if (jjtc000) {
1244: jjtree.clearNodeScope(jjtn000);
1245: jjtc000 = false;
1246: } else {
1247: jjtree.popNode();
1248: }
1249: if (jjte000 instanceof RuntimeException) {
1250: {
1251: if (true)
1252: throw (RuntimeException) jjte000;
1253: }
1254: }
1255: if (jjte000 instanceof ParseException) {
1256: {
1257: if (true)
1258: throw (ParseException) jjte000;
1259: }
1260: }
1261: {
1262: if (true)
1263: throw (Error) jjte000;
1264: }
1265: } finally {
1266: if (jjtc000) {
1267: jjtree.closeNodeScope(jjtn000, true);
1268: }
1269: }
1270: }
1271:
1272: final public void TriplesBlock() throws ParseException {
1273: TriplesSameSubject();
1274: label_11: while (true) {
1275: if (jj_2_1(2)) {
1276: ;
1277: } else {
1278: break label_11;
1279: }
1280: jj_consume_token(DOT);
1281: TriplesSameSubject();
1282: }
1283: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1284: case DOT:
1285: jj_consume_token(DOT);
1286: break;
1287: default:
1288: jj_la1[40] = jj_gen;
1289: ;
1290: }
1291: }
1292:
1293: final public void GraphPatternNotTriples() throws ParseException {
1294: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1295: case OPTIONAL:
1296: OptionalGraphPattern();
1297: break;
1298: case LBRACE:
1299: GroupOrUnionGraphPattern();
1300: break;
1301: case GRAPH:
1302: GraphGraphPattern();
1303: break;
1304: default:
1305: jj_la1[41] = jj_gen;
1306: jj_consume_token(-1);
1307: throw new ParseException();
1308: }
1309: }
1310:
1311: final public void OptionalGraphPattern() throws ParseException {
1312: /*@bgen(jjtree) OptionalGraphPattern */
1313: ASTOptionalGraphPattern jjtn000 = new ASTOptionalGraphPattern(
1314: JJTOPTIONALGRAPHPATTERN);
1315: boolean jjtc000 = true;
1316: jjtree.openNodeScope(jjtn000);
1317: try {
1318: jj_consume_token(OPTIONAL);
1319: jj_consume_token(LBRACE);
1320: GraphPattern();
1321: jj_consume_token(RBRACE);
1322: } catch (Throwable jjte000) {
1323: if (jjtc000) {
1324: jjtree.clearNodeScope(jjtn000);
1325: jjtc000 = false;
1326: } else {
1327: jjtree.popNode();
1328: }
1329: if (jjte000 instanceof RuntimeException) {
1330: {
1331: if (true)
1332: throw (RuntimeException) jjte000;
1333: }
1334: }
1335: if (jjte000 instanceof ParseException) {
1336: {
1337: if (true)
1338: throw (ParseException) jjte000;
1339: }
1340: }
1341: {
1342: if (true)
1343: throw (Error) jjte000;
1344: }
1345: } finally {
1346: if (jjtc000) {
1347: jjtree.closeNodeScope(jjtn000, true);
1348: }
1349: }
1350: }
1351:
1352: final public void GraphGraphPattern() throws ParseException {
1353: /*@bgen(jjtree) GraphGraphPattern */
1354: ASTGraphGraphPattern jjtn000 = new ASTGraphGraphPattern(
1355: JJTGRAPHGRAPHPATTERN);
1356: boolean jjtc000 = true;
1357: jjtree.openNodeScope(jjtn000);
1358: try {
1359: jj_consume_token(GRAPH);
1360: VarOrIRIref();
1361: GroupGraphPattern();
1362: } catch (Throwable jjte000) {
1363: if (jjtc000) {
1364: jjtree.clearNodeScope(jjtn000);
1365: jjtc000 = false;
1366: } else {
1367: jjtree.popNode();
1368: }
1369: if (jjte000 instanceof RuntimeException) {
1370: {
1371: if (true)
1372: throw (RuntimeException) jjte000;
1373: }
1374: }
1375: if (jjte000 instanceof ParseException) {
1376: {
1377: if (true)
1378: throw (ParseException) jjte000;
1379: }
1380: }
1381: {
1382: if (true)
1383: throw (Error) jjte000;
1384: }
1385: } finally {
1386: if (jjtc000) {
1387: jjtree.closeNodeScope(jjtn000, true);
1388: }
1389: }
1390: }
1391:
1392: final public void GroupOrUnionGraphPattern() throws ParseException {
1393: GroupGraphPattern();
1394: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1395: case UNION:
1396: jj_consume_token(UNION);
1397: ASTUnionGraphPattern jjtn001 = new ASTUnionGraphPattern(
1398: JJTUNIONGRAPHPATTERN);
1399: boolean jjtc001 = true;
1400: jjtree.openNodeScope(jjtn001);
1401: try {
1402: GroupOrUnionGraphPattern();
1403: } catch (Throwable jjte001) {
1404: if (jjtc001) {
1405: jjtree.clearNodeScope(jjtn001);
1406: jjtc001 = false;
1407: } else {
1408: jjtree.popNode();
1409: }
1410: if (jjte001 instanceof RuntimeException) {
1411: {
1412: if (true)
1413: throw (RuntimeException) jjte001;
1414: }
1415: }
1416: if (jjte001 instanceof ParseException) {
1417: {
1418: if (true)
1419: throw (ParseException) jjte001;
1420: }
1421: }
1422: {
1423: if (true)
1424: throw (Error) jjte001;
1425: }
1426: } finally {
1427: if (jjtc001) {
1428: jjtree.closeNodeScope(jjtn001, 2);
1429: }
1430: }
1431: break;
1432: default:
1433: jj_la1[42] = jj_gen;
1434: ;
1435: }
1436: }
1437:
1438: final public void Filter() throws ParseException {
1439: jj_consume_token(FILTER);
1440: Constraint();
1441: }
1442:
1443: final public void Constraint() throws ParseException {
1444: /*@bgen(jjtree) Constraint */
1445: ASTConstraint jjtn000 = new ASTConstraint(JJTCONSTRAINT);
1446: boolean jjtc000 = true;
1447: jjtree.openNodeScope(jjtn000);
1448: try {
1449: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1450: case LPAREN:
1451: BrackettedExpression();
1452: break;
1453: case STR:
1454: case LANG:
1455: case LANGMATCHES:
1456: case DATATYPE:
1457: case BOUND:
1458: case SAMETERM:
1459: case IS_IRI:
1460: case IS_BLANK:
1461: case IS_LITERAL:
1462: case REGEX:
1463: BuiltInCall();
1464: break;
1465: case Q_IRI_REF:
1466: case PNAME_NS:
1467: case PNAME_LN:
1468: FunctionCall();
1469: break;
1470: default:
1471: jj_la1[43] = jj_gen;
1472: jj_consume_token(-1);
1473: throw new ParseException();
1474: }
1475: } catch (Throwable jjte000) {
1476: if (jjtc000) {
1477: jjtree.clearNodeScope(jjtn000);
1478: jjtc000 = false;
1479: } else {
1480: jjtree.popNode();
1481: }
1482: if (jjte000 instanceof RuntimeException) {
1483: {
1484: if (true)
1485: throw (RuntimeException) jjte000;
1486: }
1487: }
1488: if (jjte000 instanceof ParseException) {
1489: {
1490: if (true)
1491: throw (ParseException) jjte000;
1492: }
1493: }
1494: {
1495: if (true)
1496: throw (Error) jjte000;
1497: }
1498: } finally {
1499: if (jjtc000) {
1500: jjtree.closeNodeScope(jjtn000, true);
1501: }
1502: }
1503: }
1504:
1505: final public void FunctionCall() throws ParseException {
1506: /*@bgen(jjtree) FunctionCall */
1507: ASTFunctionCall jjtn000 = new ASTFunctionCall(JJTFUNCTIONCALL);
1508: boolean jjtc000 = true;
1509: jjtree.openNodeScope(jjtn000);
1510: try {
1511: IRIref();
1512: ArgList();
1513: } catch (Throwable jjte000) {
1514: if (jjtc000) {
1515: jjtree.clearNodeScope(jjtn000);
1516: jjtc000 = false;
1517: } else {
1518: jjtree.popNode();
1519: }
1520: if (jjte000 instanceof RuntimeException) {
1521: {
1522: if (true)
1523: throw (RuntimeException) jjte000;
1524: }
1525: }
1526: if (jjte000 instanceof ParseException) {
1527: {
1528: if (true)
1529: throw (ParseException) jjte000;
1530: }
1531: }
1532: {
1533: if (true)
1534: throw (Error) jjte000;
1535: }
1536: } finally {
1537: if (jjtc000) {
1538: jjtree.closeNodeScope(jjtn000, true);
1539: }
1540: }
1541: }
1542:
1543: final public void ArgList() throws ParseException {
1544: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1545: case NIL:
1546: jj_consume_token(NIL);
1547: break;
1548: case LPAREN:
1549: jj_consume_token(LPAREN);
1550: Expression();
1551: label_12: while (true) {
1552: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1553: case COMMA:
1554: ;
1555: break;
1556: default:
1557: jj_la1[44] = jj_gen;
1558: break label_12;
1559: }
1560: jj_consume_token(COMMA);
1561: Expression();
1562: }
1563: jj_consume_token(RPAREN);
1564: break;
1565: default:
1566: jj_la1[45] = jj_gen;
1567: jj_consume_token(-1);
1568: throw new ParseException();
1569: }
1570: }
1571:
1572: final public void TriplesSameSubject() throws ParseException {
1573: /*@bgen(jjtree) TriplesSameSubject */
1574: ASTTriplesSameSubject jjtn000 = new ASTTriplesSameSubject(
1575: JJTTRIPLESSAMESUBJECT);
1576: boolean jjtc000 = true;
1577: jjtree.openNodeScope(jjtn000);
1578: try {
1579: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1580: case NIL:
1581: case ANON:
1582: case TRUE:
1583: case FALSE:
1584: case Q_IRI_REF:
1585: case PNAME_NS:
1586: case PNAME_LN:
1587: case BLANK_NODE_LABEL:
1588: case VAR1:
1589: case VAR2:
1590: case INTEGER:
1591: case INTEGER_POSITIVE:
1592: case INTEGER_NEGATIVE:
1593: case DECIMAL:
1594: case DECIMAL_POSITIVE:
1595: case DECIMAL_NEGATIVE:
1596: case DOUBLE:
1597: case DOUBLE_POSITIVE:
1598: case DOUBLE_NEGATIVE:
1599: case STRING_LITERAL1:
1600: case STRING_LITERAL2:
1601: case STRING_LITERAL_LONG1:
1602: case STRING_LITERAL_LONG2:
1603: VarOrTerm();
1604: PropertyList();
1605: break;
1606: case LPAREN:
1607: case LBRACK:
1608: TriplesNode();
1609: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1610: case IS_A:
1611: case Q_IRI_REF:
1612: case PNAME_NS:
1613: case PNAME_LN:
1614: case VAR1:
1615: case VAR2:
1616: PropertyList();
1617: break;
1618: default:
1619: jj_la1[46] = jj_gen;
1620: ;
1621: }
1622: break;
1623: default:
1624: jj_la1[47] = jj_gen;
1625: jj_consume_token(-1);
1626: throw new ParseException();
1627: }
1628: } catch (Throwable jjte000) {
1629: if (jjtc000) {
1630: jjtree.clearNodeScope(jjtn000);
1631: jjtc000 = false;
1632: } else {
1633: jjtree.popNode();
1634: }
1635: if (jjte000 instanceof RuntimeException) {
1636: {
1637: if (true)
1638: throw (RuntimeException) jjte000;
1639: }
1640: }
1641: if (jjte000 instanceof ParseException) {
1642: {
1643: if (true)
1644: throw (ParseException) jjte000;
1645: }
1646: }
1647: {
1648: if (true)
1649: throw (Error) jjte000;
1650: }
1651: } finally {
1652: if (jjtc000) {
1653: jjtree.closeNodeScope(jjtn000, true);
1654: }
1655: }
1656: }
1657:
1658: final public void PropertyList() throws ParseException {
1659: /*@bgen(jjtree) PropertyList */
1660: ASTPropertyList jjtn000 = new ASTPropertyList(JJTPROPERTYLIST);
1661: boolean jjtc000 = true;
1662: jjtree.openNodeScope(jjtn000);
1663: try {
1664: Verb();
1665: ObjectList();
1666: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1667: case SEMICOLON:
1668: jj_consume_token(SEMICOLON);
1669: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1670: case IS_A:
1671: case Q_IRI_REF:
1672: case PNAME_NS:
1673: case PNAME_LN:
1674: case VAR1:
1675: case VAR2:
1676: PropertyList();
1677: break;
1678: default:
1679: jj_la1[48] = jj_gen;
1680: ;
1681: }
1682: break;
1683: default:
1684: jj_la1[49] = jj_gen;
1685: ;
1686: }
1687: } catch (Throwable jjte000) {
1688: if (jjtc000) {
1689: jjtree.clearNodeScope(jjtn000);
1690: jjtc000 = false;
1691: } else {
1692: jjtree.popNode();
1693: }
1694: if (jjte000 instanceof RuntimeException) {
1695: {
1696: if (true)
1697: throw (RuntimeException) jjte000;
1698: }
1699: }
1700: if (jjte000 instanceof ParseException) {
1701: {
1702: if (true)
1703: throw (ParseException) jjte000;
1704: }
1705: }
1706: {
1707: if (true)
1708: throw (Error) jjte000;
1709: }
1710: } finally {
1711: if (jjtc000) {
1712: jjtree.closeNodeScope(jjtn000, true);
1713: }
1714: }
1715: }
1716:
1717: final public void ObjectList() throws ParseException {
1718: /*@bgen(jjtree) ObjectList */
1719: ASTObjectList jjtn000 = new ASTObjectList(JJTOBJECTLIST);
1720: boolean jjtc000 = true;
1721: jjtree.openNodeScope(jjtn000);
1722: try {
1723: Object();
1724: label_13: while (true) {
1725: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1726: case COMMA:
1727: ;
1728: break;
1729: default:
1730: jj_la1[50] = jj_gen;
1731: break label_13;
1732: }
1733: jj_consume_token(COMMA);
1734: Object();
1735: }
1736: } catch (Throwable jjte000) {
1737: if (jjtc000) {
1738: jjtree.clearNodeScope(jjtn000);
1739: jjtc000 = false;
1740: } else {
1741: jjtree.popNode();
1742: }
1743: if (jjte000 instanceof RuntimeException) {
1744: {
1745: if (true)
1746: throw (RuntimeException) jjte000;
1747: }
1748: }
1749: if (jjte000 instanceof ParseException) {
1750: {
1751: if (true)
1752: throw (ParseException) jjte000;
1753: }
1754: }
1755: {
1756: if (true)
1757: throw (Error) jjte000;
1758: }
1759: } finally {
1760: if (jjtc000) {
1761: jjtree.closeNodeScope(jjtn000, true);
1762: }
1763: }
1764: }
1765:
1766: final public void Object() throws ParseException {
1767: GraphNode();
1768: }
1769:
1770: final public void Verb() throws ParseException {
1771: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1772: case Q_IRI_REF:
1773: case PNAME_NS:
1774: case PNAME_LN:
1775: case VAR1:
1776: case VAR2:
1777: VarOrIRIref();
1778: break;
1779: case IS_A:
1780: jj_consume_token(IS_A);
1781: ASTIRI jjtn001 = new ASTIRI(JJTIRI);
1782: boolean jjtc001 = true;
1783: jjtree.openNodeScope(jjtn001);
1784: try {
1785: jjtree.closeNodeScope(jjtn001, true);
1786: jjtc001 = false;
1787: jjtn001.setValue(RDF.TYPE.toString());
1788: } finally {
1789: if (jjtc001) {
1790: jjtree.closeNodeScope(jjtn001, true);
1791: }
1792: }
1793: break;
1794: default:
1795: jj_la1[51] = jj_gen;
1796: jj_consume_token(-1);
1797: throw new ParseException();
1798: }
1799: }
1800:
1801: final public void TriplesNode() throws ParseException {
1802: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1803: case LPAREN:
1804: Collection();
1805: break;
1806: case LBRACK:
1807: BlankNodePropertyList();
1808: break;
1809: default:
1810: jj_la1[52] = jj_gen;
1811: jj_consume_token(-1);
1812: throw new ParseException();
1813: }
1814: }
1815:
1816: final public void BlankNodePropertyList() throws ParseException {
1817: /*@bgen(jjtree) BlankNodePropertyList */
1818: ASTBlankNodePropertyList jjtn000 = new ASTBlankNodePropertyList(
1819: JJTBLANKNODEPROPERTYLIST);
1820: boolean jjtc000 = true;
1821: jjtree.openNodeScope(jjtn000);
1822: try {
1823: jj_consume_token(LBRACK);
1824: PropertyList();
1825: jj_consume_token(RBRACK);
1826: } catch (Throwable jjte000) {
1827: if (jjtc000) {
1828: jjtree.clearNodeScope(jjtn000);
1829: jjtc000 = false;
1830: } else {
1831: jjtree.popNode();
1832: }
1833: if (jjte000 instanceof RuntimeException) {
1834: {
1835: if (true)
1836: throw (RuntimeException) jjte000;
1837: }
1838: }
1839: if (jjte000 instanceof ParseException) {
1840: {
1841: if (true)
1842: throw (ParseException) jjte000;
1843: }
1844: }
1845: {
1846: if (true)
1847: throw (Error) jjte000;
1848: }
1849: } finally {
1850: if (jjtc000) {
1851: jjtree.closeNodeScope(jjtn000, true);
1852: }
1853: }
1854: }
1855:
1856: final public void Collection() throws ParseException {
1857: /*@bgen(jjtree) Collection */
1858: ASTCollection jjtn000 = new ASTCollection(JJTCOLLECTION);
1859: boolean jjtc000 = true;
1860: jjtree.openNodeScope(jjtn000);
1861: try {
1862: jj_consume_token(LPAREN);
1863: label_14: while (true) {
1864: GraphNode();
1865: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1866: case LPAREN:
1867: case LBRACK:
1868: case NIL:
1869: case ANON:
1870: case TRUE:
1871: case FALSE:
1872: case Q_IRI_REF:
1873: case PNAME_NS:
1874: case PNAME_LN:
1875: case BLANK_NODE_LABEL:
1876: case VAR1:
1877: case VAR2:
1878: case INTEGER:
1879: case INTEGER_POSITIVE:
1880: case INTEGER_NEGATIVE:
1881: case DECIMAL:
1882: case DECIMAL_POSITIVE:
1883: case DECIMAL_NEGATIVE:
1884: case DOUBLE:
1885: case DOUBLE_POSITIVE:
1886: case DOUBLE_NEGATIVE:
1887: case STRING_LITERAL1:
1888: case STRING_LITERAL2:
1889: case STRING_LITERAL_LONG1:
1890: case STRING_LITERAL_LONG2:
1891: ;
1892: break;
1893: default:
1894: jj_la1[53] = jj_gen;
1895: break label_14;
1896: }
1897: }
1898: jj_consume_token(RPAREN);
1899: } catch (Throwable jjte000) {
1900: if (jjtc000) {
1901: jjtree.clearNodeScope(jjtn000);
1902: jjtc000 = false;
1903: } else {
1904: jjtree.popNode();
1905: }
1906: if (jjte000 instanceof RuntimeException) {
1907: {
1908: if (true)
1909: throw (RuntimeException) jjte000;
1910: }
1911: }
1912: if (jjte000 instanceof ParseException) {
1913: {
1914: if (true)
1915: throw (ParseException) jjte000;
1916: }
1917: }
1918: {
1919: if (true)
1920: throw (Error) jjte000;
1921: }
1922: } finally {
1923: if (jjtc000) {
1924: jjtree.closeNodeScope(jjtn000, true);
1925: }
1926: }
1927: }
1928:
1929: final public void GraphNode() throws ParseException {
1930: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1931: case NIL:
1932: case ANON:
1933: case TRUE:
1934: case FALSE:
1935: case Q_IRI_REF:
1936: case PNAME_NS:
1937: case PNAME_LN:
1938: case BLANK_NODE_LABEL:
1939: case VAR1:
1940: case VAR2:
1941: case INTEGER:
1942: case INTEGER_POSITIVE:
1943: case INTEGER_NEGATIVE:
1944: case DECIMAL:
1945: case DECIMAL_POSITIVE:
1946: case DECIMAL_NEGATIVE:
1947: case DOUBLE:
1948: case DOUBLE_POSITIVE:
1949: case DOUBLE_NEGATIVE:
1950: case STRING_LITERAL1:
1951: case STRING_LITERAL2:
1952: case STRING_LITERAL_LONG1:
1953: case STRING_LITERAL_LONG2:
1954: VarOrTerm();
1955: break;
1956: case LPAREN:
1957: case LBRACK:
1958: TriplesNode();
1959: break;
1960: default:
1961: jj_la1[54] = jj_gen;
1962: jj_consume_token(-1);
1963: throw new ParseException();
1964: }
1965: }
1966:
1967: final public void VarOrTerm() throws ParseException {
1968: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1969: case VAR1:
1970: case VAR2:
1971: Var();
1972: break;
1973: case NIL:
1974: case ANON:
1975: case TRUE:
1976: case FALSE:
1977: case Q_IRI_REF:
1978: case PNAME_NS:
1979: case PNAME_LN:
1980: case BLANK_NODE_LABEL:
1981: case INTEGER:
1982: case INTEGER_POSITIVE:
1983: case INTEGER_NEGATIVE:
1984: case DECIMAL:
1985: case DECIMAL_POSITIVE:
1986: case DECIMAL_NEGATIVE:
1987: case DOUBLE:
1988: case DOUBLE_POSITIVE:
1989: case DOUBLE_NEGATIVE:
1990: case STRING_LITERAL1:
1991: case STRING_LITERAL2:
1992: case STRING_LITERAL_LONG1:
1993: case STRING_LITERAL_LONG2:
1994: GraphTerm();
1995: break;
1996: default:
1997: jj_la1[55] = jj_gen;
1998: jj_consume_token(-1);
1999: throw new ParseException();
2000: }
2001: }
2002:
2003: final public void VarOrIRIref() throws ParseException {
2004: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2005: case VAR1:
2006: case VAR2:
2007: Var();
2008: break;
2009: case Q_IRI_REF:
2010: case PNAME_NS:
2011: case PNAME_LN:
2012: IRIref();
2013: break;
2014: default:
2015: jj_la1[56] = jj_gen;
2016: jj_consume_token(-1);
2017: throw new ParseException();
2018: }
2019: }
2020:
2021: final public void Var() throws ParseException {
2022: /*@bgen(jjtree) Var */
2023: ASTVar jjtn000 = new ASTVar(JJTVAR);
2024: boolean jjtc000 = true;
2025: jjtree.openNodeScope(jjtn000);
2026: Token t;
2027: try {
2028: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2029: case VAR1:
2030: t = jj_consume_token(VAR1);
2031: break;
2032: case VAR2:
2033: t = jj_consume_token(VAR2);
2034: break;
2035: default:
2036: jj_la1[57] = jj_gen;
2037: jj_consume_token(-1);
2038: throw new ParseException();
2039: }
2040: jjtree.closeNodeScope(jjtn000, true);
2041: jjtc000 = false;
2042: jjtn000.setName(t.image.substring(1));
2043: } finally {
2044: if (jjtc000) {
2045: jjtree.closeNodeScope(jjtn000, true);
2046: }
2047: }
2048: }
2049:
2050: final public void GraphTerm() throws ParseException {
2051: boolean positive = true;
2052: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2053: case Q_IRI_REF:
2054: case PNAME_NS:
2055: case PNAME_LN:
2056: IRIref();
2057: break;
2058: case STRING_LITERAL1:
2059: case STRING_LITERAL2:
2060: case STRING_LITERAL_LONG1:
2061: case STRING_LITERAL_LONG2:
2062: RDFLiteral();
2063: break;
2064: case INTEGER:
2065: case INTEGER_POSITIVE:
2066: case INTEGER_NEGATIVE:
2067: case DECIMAL:
2068: case DECIMAL_POSITIVE:
2069: case DECIMAL_NEGATIVE:
2070: case DOUBLE:
2071: case DOUBLE_POSITIVE:
2072: case DOUBLE_NEGATIVE:
2073: NumericLiteral();
2074: break;
2075: case TRUE:
2076: case FALSE:
2077: BooleanLiteral();
2078: break;
2079: case ANON:
2080: case BLANK_NODE_LABEL:
2081: BlankNode();
2082: break;
2083: case NIL:
2084: jj_consume_token(NIL);
2085: ASTIRI jjtn001 = new ASTIRI(JJTIRI);
2086: boolean jjtc001 = true;
2087: jjtree.openNodeScope(jjtn001);
2088: try {
2089: jjtree.closeNodeScope(jjtn001, true);
2090: jjtc001 = false;
2091: jjtn001.setValue(RDF.NIL.toString());
2092: } finally {
2093: if (jjtc001) {
2094: jjtree.closeNodeScope(jjtn001, true);
2095: }
2096: }
2097: break;
2098: default:
2099: jj_la1[58] = jj_gen;
2100: jj_consume_token(-1);
2101: throw new ParseException();
2102: }
2103: }
2104:
2105: final public void Expression() throws ParseException {
2106: ConditionalOrExpression();
2107: }
2108:
2109: final public void ConditionalOrExpression() throws ParseException {
2110: ConditionalAndExpression();
2111: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2112: case OR:
2113: jj_consume_token(OR);
2114: ASTOr jjtn001 = new ASTOr(JJTOR);
2115: boolean jjtc001 = true;
2116: jjtree.openNodeScope(jjtn001);
2117: try {
2118: ConditionalOrExpression();
2119: } catch (Throwable jjte001) {
2120: if (jjtc001) {
2121: jjtree.clearNodeScope(jjtn001);
2122: jjtc001 = false;
2123: } else {
2124: jjtree.popNode();
2125: }
2126: if (jjte001 instanceof RuntimeException) {
2127: {
2128: if (true)
2129: throw (RuntimeException) jjte001;
2130: }
2131: }
2132: if (jjte001 instanceof ParseException) {
2133: {
2134: if (true)
2135: throw (ParseException) jjte001;
2136: }
2137: }
2138: {
2139: if (true)
2140: throw (Error) jjte001;
2141: }
2142: } finally {
2143: if (jjtc001) {
2144: jjtree.closeNodeScope(jjtn001, 2);
2145: }
2146: }
2147: break;
2148: default:
2149: jj_la1[59] = jj_gen;
2150: ;
2151: }
2152: }
2153:
2154: final public void ConditionalAndExpression() throws ParseException {
2155: ValueLogical();
2156: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2157: case AND:
2158: jj_consume_token(AND);
2159: ASTAnd jjtn001 = new ASTAnd(JJTAND);
2160: boolean jjtc001 = true;
2161: jjtree.openNodeScope(jjtn001);
2162: try {
2163: ConditionalAndExpression();
2164: } catch (Throwable jjte001) {
2165: if (jjtc001) {
2166: jjtree.clearNodeScope(jjtn001);
2167: jjtc001 = false;
2168: } else {
2169: jjtree.popNode();
2170: }
2171: if (jjte001 instanceof RuntimeException) {
2172: {
2173: if (true)
2174: throw (RuntimeException) jjte001;
2175: }
2176: }
2177: if (jjte001 instanceof ParseException) {
2178: {
2179: if (true)
2180: throw (ParseException) jjte001;
2181: }
2182: }
2183: {
2184: if (true)
2185: throw (Error) jjte001;
2186: }
2187: } finally {
2188: if (jjtc001) {
2189: jjtree.closeNodeScope(jjtn001, 2);
2190: }
2191: }
2192: break;
2193: default:
2194: jj_la1[60] = jj_gen;
2195: ;
2196: }
2197: }
2198:
2199: final public void ValueLogical() throws ParseException {
2200: RelationalExpression();
2201: }
2202:
2203: final public void RelationalExpression() throws ParseException {
2204: NumericExpression();
2205: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2206: case EQ:
2207: case NE:
2208: case GT:
2209: case LT:
2210: case LE:
2211: case GE:
2212: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2213: case EQ:
2214: jj_consume_token(EQ);
2215: NumericExpression();
2216: ASTCompare jjtn001 = new ASTCompare(JJTCOMPARE);
2217: boolean jjtc001 = true;
2218: jjtree.openNodeScope(jjtn001);
2219: try {
2220: jjtree.closeNodeScope(jjtn001, 2);
2221: jjtc001 = false;
2222: jjtn001.setOperator(CompareOp.EQ);
2223: } finally {
2224: if (jjtc001) {
2225: jjtree.closeNodeScope(jjtn001, 2);
2226: }
2227: }
2228: break;
2229: case NE:
2230: jj_consume_token(NE);
2231: NumericExpression();
2232: ASTCompare jjtn002 = new ASTCompare(JJTCOMPARE);
2233: boolean jjtc002 = true;
2234: jjtree.openNodeScope(jjtn002);
2235: try {
2236: jjtree.closeNodeScope(jjtn002, 2);
2237: jjtc002 = false;
2238: jjtn002.setOperator(CompareOp.NE);
2239: } finally {
2240: if (jjtc002) {
2241: jjtree.closeNodeScope(jjtn002, 2);
2242: }
2243: }
2244: break;
2245: case LT:
2246: jj_consume_token(LT);
2247: NumericExpression();
2248: ASTCompare jjtn003 = new ASTCompare(JJTCOMPARE);
2249: boolean jjtc003 = true;
2250: jjtree.openNodeScope(jjtn003);
2251: try {
2252: jjtree.closeNodeScope(jjtn003, 2);
2253: jjtc003 = false;
2254: jjtn003.setOperator(CompareOp.LT);
2255: } finally {
2256: if (jjtc003) {
2257: jjtree.closeNodeScope(jjtn003, 2);
2258: }
2259: }
2260: break;
2261: case LE:
2262: jj_consume_token(LE);
2263: NumericExpression();
2264: ASTCompare jjtn004 = new ASTCompare(JJTCOMPARE);
2265: boolean jjtc004 = true;
2266: jjtree.openNodeScope(jjtn004);
2267: try {
2268: jjtree.closeNodeScope(jjtn004, 2);
2269: jjtc004 = false;
2270: jjtn004.setOperator(CompareOp.LE);
2271: } finally {
2272: if (jjtc004) {
2273: jjtree.closeNodeScope(jjtn004, 2);
2274: }
2275: }
2276: break;
2277: case GE:
2278: jj_consume_token(GE);
2279: NumericExpression();
2280: ASTCompare jjtn005 = new ASTCompare(JJTCOMPARE);
2281: boolean jjtc005 = true;
2282: jjtree.openNodeScope(jjtn005);
2283: try {
2284: jjtree.closeNodeScope(jjtn005, 2);
2285: jjtc005 = false;
2286: jjtn005.setOperator(CompareOp.GE);
2287: } finally {
2288: if (jjtc005) {
2289: jjtree.closeNodeScope(jjtn005, 2);
2290: }
2291: }
2292: break;
2293: case GT:
2294: jj_consume_token(GT);
2295: NumericExpression();
2296: ASTCompare jjtn006 = new ASTCompare(JJTCOMPARE);
2297: boolean jjtc006 = true;
2298: jjtree.openNodeScope(jjtn006);
2299: try {
2300: jjtree.closeNodeScope(jjtn006, 2);
2301: jjtc006 = false;
2302: jjtn006.setOperator(CompareOp.GT);
2303: } finally {
2304: if (jjtc006) {
2305: jjtree.closeNodeScope(jjtn006, 2);
2306: }
2307: }
2308: break;
2309: default:
2310: jj_la1[61] = jj_gen;
2311: jj_consume_token(-1);
2312: throw new ParseException();
2313: }
2314: break;
2315: default:
2316: jj_la1[62] = jj_gen;
2317: ;
2318: }
2319: }
2320:
2321: final public void NumericExpression() throws ParseException {
2322: AdditiveExpression();
2323: }
2324:
2325: final public void AdditiveExpression() throws ParseException {
2326: MultiplicativeExpression();
2327: label_15: while (true) {
2328: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2329: case PLUS:
2330: case MINUS:
2331: case INTEGER_POSITIVE:
2332: case INTEGER_NEGATIVE:
2333: case DECIMAL_POSITIVE:
2334: case DECIMAL_NEGATIVE:
2335: case DOUBLE_POSITIVE:
2336: case DOUBLE_NEGATIVE:
2337: ;
2338: break;
2339: default:
2340: jj_la1[63] = jj_gen;
2341: break label_15;
2342: }
2343: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2344: case PLUS:
2345: jj_consume_token(PLUS);
2346: MultiplicativeExpression();
2347: ASTMath jjtn001 = new ASTMath(JJTMATH);
2348: boolean jjtc001 = true;
2349: jjtree.openNodeScope(jjtn001);
2350: try {
2351: jjtree.closeNodeScope(jjtn001, 2);
2352: jjtc001 = false;
2353: jjtn001.setOperator(MathOp.PLUS);
2354: } finally {
2355: if (jjtc001) {
2356: jjtree.closeNodeScope(jjtn001, 2);
2357: }
2358: }
2359: break;
2360: case MINUS:
2361: jj_consume_token(MINUS);
2362: MultiplicativeExpression();
2363: ASTMath jjtn002 = new ASTMath(JJTMATH);
2364: boolean jjtc002 = true;
2365: jjtree.openNodeScope(jjtn002);
2366: try {
2367: jjtree.closeNodeScope(jjtn002, 2);
2368: jjtc002 = false;
2369: jjtn002.setOperator(MathOp.MINUS);
2370: } finally {
2371: if (jjtc002) {
2372: jjtree.closeNodeScope(jjtn002, 2);
2373: }
2374: }
2375: break;
2376: case INTEGER_POSITIVE:
2377: case DECIMAL_POSITIVE:
2378: case DOUBLE_POSITIVE:
2379: NumericLiteralPositive();
2380: ASTMath jjtn003 = new ASTMath(JJTMATH);
2381: boolean jjtc003 = true;
2382: jjtree.openNodeScope(jjtn003);
2383: try {
2384: jjtree.closeNodeScope(jjtn003, 2);
2385: jjtc003 = false;
2386: jjtn003.setOperator(MathOp.PLUS);
2387: } finally {
2388: if (jjtc003) {
2389: jjtree.closeNodeScope(jjtn003, 2);
2390: }
2391: }
2392: break;
2393: case INTEGER_NEGATIVE:
2394: case DECIMAL_NEGATIVE:
2395: case DOUBLE_NEGATIVE:
2396: NumericLiteralNegative();
2397: ASTMath jjtn004 = new ASTMath(JJTMATH);
2398: boolean jjtc004 = true;
2399: jjtree.openNodeScope(jjtn004);
2400: try {
2401: jjtree.closeNodeScope(jjtn004, 2);
2402: jjtc004 = false;
2403: jjtn004.setOperator(MathOp.PLUS);
2404: } finally {
2405: if (jjtc004) {
2406: jjtree.closeNodeScope(jjtn004, 2);
2407: }
2408: }
2409: break;
2410: default:
2411: jj_la1[64] = jj_gen;
2412: jj_consume_token(-1);
2413: throw new ParseException();
2414: }
2415: }
2416: }
2417:
2418: final public void MultiplicativeExpression() throws ParseException {
2419: UnaryExpression();
2420: label_16: while (true) {
2421: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2422: case STAR:
2423: case SLASH:
2424: ;
2425: break;
2426: default:
2427: jj_la1[65] = jj_gen;
2428: break label_16;
2429: }
2430: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2431: case STAR:
2432: jj_consume_token(STAR);
2433: UnaryExpression();
2434: ASTMath jjtn001 = new ASTMath(JJTMATH);
2435: boolean jjtc001 = true;
2436: jjtree.openNodeScope(jjtn001);
2437: try {
2438: jjtree.closeNodeScope(jjtn001, 2);
2439: jjtc001 = false;
2440: jjtn001.setOperator(MathOp.MULTIPLY);
2441: } finally {
2442: if (jjtc001) {
2443: jjtree.closeNodeScope(jjtn001, 2);
2444: }
2445: }
2446: break;
2447: case SLASH:
2448: jj_consume_token(SLASH);
2449: UnaryExpression();
2450: ASTMath jjtn002 = new ASTMath(JJTMATH);
2451: boolean jjtc002 = true;
2452: jjtree.openNodeScope(jjtn002);
2453: try {
2454: jjtree.closeNodeScope(jjtn002, 2);
2455: jjtc002 = false;
2456: jjtn002.setOperator(MathOp.DIVIDE);
2457: } finally {
2458: if (jjtc002) {
2459: jjtree.closeNodeScope(jjtn002, 2);
2460: }
2461: }
2462: break;
2463: default:
2464: jj_la1[66] = jj_gen;
2465: jj_consume_token(-1);
2466: throw new ParseException();
2467: }
2468: }
2469: }
2470:
2471: final public void UnaryExpression() throws ParseException {
2472: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2473: case NOT:
2474: jj_consume_token(NOT);
2475: ASTNot jjtn001 = new ASTNot(JJTNOT);
2476: boolean jjtc001 = true;
2477: jjtree.openNodeScope(jjtn001);
2478: try {
2479: PrimaryExpression();
2480: } catch (Throwable jjte001) {
2481: if (jjtc001) {
2482: jjtree.clearNodeScope(jjtn001);
2483: jjtc001 = false;
2484: } else {
2485: jjtree.popNode();
2486: }
2487: if (jjte001 instanceof RuntimeException) {
2488: {
2489: if (true)
2490: throw (RuntimeException) jjte001;
2491: }
2492: }
2493: if (jjte001 instanceof ParseException) {
2494: {
2495: if (true)
2496: throw (ParseException) jjte001;
2497: }
2498: }
2499: {
2500: if (true)
2501: throw (Error) jjte001;
2502: }
2503: } finally {
2504: if (jjtc001) {
2505: jjtree.closeNodeScope(jjtn001, true);
2506: }
2507: }
2508: break;
2509: case LPAREN:
2510: case PLUS:
2511: case STR:
2512: case LANG:
2513: case LANGMATCHES:
2514: case DATATYPE:
2515: case BOUND:
2516: case SAMETERM:
2517: case IS_IRI:
2518: case IS_BLANK:
2519: case IS_LITERAL:
2520: case REGEX:
2521: case TRUE:
2522: case FALSE:
2523: case Q_IRI_REF:
2524: case PNAME_NS:
2525: case PNAME_LN:
2526: case VAR1:
2527: case VAR2:
2528: case INTEGER:
2529: case INTEGER_POSITIVE:
2530: case INTEGER_NEGATIVE:
2531: case DECIMAL:
2532: case DECIMAL_POSITIVE:
2533: case DECIMAL_NEGATIVE:
2534: case DOUBLE:
2535: case DOUBLE_POSITIVE:
2536: case DOUBLE_NEGATIVE:
2537: case STRING_LITERAL1:
2538: case STRING_LITERAL2:
2539: case STRING_LITERAL_LONG1:
2540: case STRING_LITERAL_LONG2:
2541: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2542: case PLUS:
2543: jj_consume_token(PLUS);
2544: break;
2545: default:
2546: jj_la1[67] = jj_gen;
2547: ;
2548: }
2549: PrimaryExpression();
2550: break;
2551: case MINUS:
2552: UnaryMinus();
2553: PrimaryExpression();
2554: ASTMath jjtn002 = new ASTMath(JJTMATH);
2555: boolean jjtc002 = true;
2556: jjtree.openNodeScope(jjtn002);
2557: try {
2558: jjtree.closeNodeScope(jjtn002, 2);
2559: jjtc002 = false;
2560: jjtn002.setOperator(MathOp.MULTIPLY);
2561: } finally {
2562: if (jjtc002) {
2563: jjtree.closeNodeScope(jjtn002, 2);
2564: }
2565: }
2566: break;
2567: default:
2568: jj_la1[68] = jj_gen;
2569: jj_consume_token(-1);
2570: throw new ParseException();
2571: }
2572: }
2573:
2574: final public void UnaryMinus() throws ParseException {
2575: /*@bgen(jjtree) NumericLiteral */
2576: ASTNumericLiteral jjtn000 = new ASTNumericLiteral(
2577: JJTNUMERICLITERAL);
2578: boolean jjtc000 = true;
2579: jjtree.openNodeScope(jjtn000);
2580: try {
2581: jj_consume_token(MINUS);
2582: jjtree.closeNodeScope(jjtn000, true);
2583: jjtc000 = false;
2584: jjtn000.setValue("-1");
2585: jjtn000.setDatatype(XMLSchema.INTEGER);
2586: } finally {
2587: if (jjtc000) {
2588: jjtree.closeNodeScope(jjtn000, true);
2589: }
2590: }
2591: }
2592:
2593: final public void PrimaryExpression() throws ParseException {
2594: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2595: case LPAREN:
2596: BrackettedExpression();
2597: break;
2598: case STR:
2599: case LANG:
2600: case LANGMATCHES:
2601: case DATATYPE:
2602: case BOUND:
2603: case SAMETERM:
2604: case IS_IRI:
2605: case IS_BLANK:
2606: case IS_LITERAL:
2607: case REGEX:
2608: BuiltInCall();
2609: break;
2610: default:
2611: jj_la1[69] = jj_gen;
2612: if (jj_2_2(2)) {
2613: FunctionCall();
2614: } else {
2615: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2616: case Q_IRI_REF:
2617: case PNAME_NS:
2618: case PNAME_LN:
2619: IRIref();
2620: break;
2621: case STRING_LITERAL1:
2622: case STRING_LITERAL2:
2623: case STRING_LITERAL_LONG1:
2624: case STRING_LITERAL_LONG2:
2625: RDFLiteral();
2626: break;
2627: case INTEGER:
2628: case INTEGER_POSITIVE:
2629: case INTEGER_NEGATIVE:
2630: case DECIMAL:
2631: case DECIMAL_POSITIVE:
2632: case DECIMAL_NEGATIVE:
2633: case DOUBLE:
2634: case DOUBLE_POSITIVE:
2635: case DOUBLE_NEGATIVE:
2636: NumericLiteral();
2637: break;
2638: case TRUE:
2639: case FALSE:
2640: BooleanLiteral();
2641: break;
2642: case VAR1:
2643: case VAR2:
2644: Var();
2645: break;
2646: default:
2647: jj_la1[70] = jj_gen;
2648: jj_consume_token(-1);
2649: throw new ParseException();
2650: }
2651: }
2652: }
2653: }
2654:
2655: final public void BrackettedExpression() throws ParseException {
2656: jj_consume_token(LPAREN);
2657: Expression();
2658: jj_consume_token(RPAREN);
2659: }
2660:
2661: final public void BuiltInCall() throws ParseException {
2662: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2663: case STR:
2664: Str();
2665: break;
2666: case LANG:
2667: Lang();
2668: break;
2669: case LANGMATCHES:
2670: LangMatches();
2671: break;
2672: case DATATYPE:
2673: Datatype();
2674: break;
2675: case BOUND:
2676: Bound();
2677: break;
2678: case SAMETERM:
2679: SameTerm();
2680: break;
2681: case IS_IRI:
2682: IsIRI();
2683: break;
2684: case IS_BLANK:
2685: IsBlank();
2686: break;
2687: case IS_LITERAL:
2688: IsLiteral();
2689: break;
2690: case REGEX:
2691: RegexExpression();
2692: break;
2693: default:
2694: jj_la1[71] = jj_gen;
2695: jj_consume_token(-1);
2696: throw new ParseException();
2697: }
2698: }
2699:
2700: final public void Str() throws ParseException {
2701: /*@bgen(jjtree) Str */
2702: ASTStr jjtn000 = new ASTStr(JJTSTR);
2703: boolean jjtc000 = true;
2704: jjtree.openNodeScope(jjtn000);
2705: try {
2706: jj_consume_token(STR);
2707: jj_consume_token(LPAREN);
2708: Expression();
2709: jj_consume_token(RPAREN);
2710: } catch (Throwable jjte000) {
2711: if (jjtc000) {
2712: jjtree.clearNodeScope(jjtn000);
2713: jjtc000 = false;
2714: } else {
2715: jjtree.popNode();
2716: }
2717: if (jjte000 instanceof RuntimeException) {
2718: {
2719: if (true)
2720: throw (RuntimeException) jjte000;
2721: }
2722: }
2723: if (jjte000 instanceof ParseException) {
2724: {
2725: if (true)
2726: throw (ParseException) jjte000;
2727: }
2728: }
2729: {
2730: if (true)
2731: throw (Error) jjte000;
2732: }
2733: } finally {
2734: if (jjtc000) {
2735: jjtree.closeNodeScope(jjtn000, true);
2736: }
2737: }
2738: }
2739:
2740: final public void Lang() throws ParseException {
2741: /*@bgen(jjtree) Lang */
2742: ASTLang jjtn000 = new ASTLang(JJTLANG);
2743: boolean jjtc000 = true;
2744: jjtree.openNodeScope(jjtn000);
2745: try {
2746: jj_consume_token(LANG);
2747: jj_consume_token(LPAREN);
2748: Expression();
2749: jj_consume_token(RPAREN);
2750: } catch (Throwable jjte000) {
2751: if (jjtc000) {
2752: jjtree.clearNodeScope(jjtn000);
2753: jjtc000 = false;
2754: } else {
2755: jjtree.popNode();
2756: }
2757: if (jjte000 instanceof RuntimeException) {
2758: {
2759: if (true)
2760: throw (RuntimeException) jjte000;
2761: }
2762: }
2763: if (jjte000 instanceof ParseException) {
2764: {
2765: if (true)
2766: throw (ParseException) jjte000;
2767: }
2768: }
2769: {
2770: if (true)
2771: throw (Error) jjte000;
2772: }
2773: } finally {
2774: if (jjtc000) {
2775: jjtree.closeNodeScope(jjtn000, true);
2776: }
2777: }
2778: }
2779:
2780: final public void LangMatches() throws ParseException {
2781: /*@bgen(jjtree) LangMatches */
2782: ASTLangMatches jjtn000 = new ASTLangMatches(JJTLANGMATCHES);
2783: boolean jjtc000 = true;
2784: jjtree.openNodeScope(jjtn000);
2785: try {
2786: jj_consume_token(LANGMATCHES);
2787: jj_consume_token(LPAREN);
2788: Expression();
2789: jj_consume_token(COMMA);
2790: Expression();
2791: jj_consume_token(RPAREN);
2792: } catch (Throwable jjte000) {
2793: if (jjtc000) {
2794: jjtree.clearNodeScope(jjtn000);
2795: jjtc000 = false;
2796: } else {
2797: jjtree.popNode();
2798: }
2799: if (jjte000 instanceof RuntimeException) {
2800: {
2801: if (true)
2802: throw (RuntimeException) jjte000;
2803: }
2804: }
2805: if (jjte000 instanceof ParseException) {
2806: {
2807: if (true)
2808: throw (ParseException) jjte000;
2809: }
2810: }
2811: {
2812: if (true)
2813: throw (Error) jjte000;
2814: }
2815: } finally {
2816: if (jjtc000) {
2817: jjtree.closeNodeScope(jjtn000, true);
2818: }
2819: }
2820: }
2821:
2822: final public void Datatype() throws ParseException {
2823: /*@bgen(jjtree) Datatype */
2824: ASTDatatype jjtn000 = new ASTDatatype(JJTDATATYPE);
2825: boolean jjtc000 = true;
2826: jjtree.openNodeScope(jjtn000);
2827: try {
2828: jj_consume_token(DATATYPE);
2829: jj_consume_token(LPAREN);
2830: Expression();
2831: jj_consume_token(RPAREN);
2832: } catch (Throwable jjte000) {
2833: if (jjtc000) {
2834: jjtree.clearNodeScope(jjtn000);
2835: jjtc000 = false;
2836: } else {
2837: jjtree.popNode();
2838: }
2839: if (jjte000 instanceof RuntimeException) {
2840: {
2841: if (true)
2842: throw (RuntimeException) jjte000;
2843: }
2844: }
2845: if (jjte000 instanceof ParseException) {
2846: {
2847: if (true)
2848: throw (ParseException) jjte000;
2849: }
2850: }
2851: {
2852: if (true)
2853: throw (Error) jjte000;
2854: }
2855: } finally {
2856: if (jjtc000) {
2857: jjtree.closeNodeScope(jjtn000, true);
2858: }
2859: }
2860: }
2861:
2862: final public void Bound() throws ParseException {
2863: /*@bgen(jjtree) Bound */
2864: ASTBound jjtn000 = new ASTBound(JJTBOUND);
2865: boolean jjtc000 = true;
2866: jjtree.openNodeScope(jjtn000);
2867: try {
2868: jj_consume_token(BOUND);
2869: jj_consume_token(LPAREN);
2870: Var();
2871: jj_consume_token(RPAREN);
2872: } catch (Throwable jjte000) {
2873: if (jjtc000) {
2874: jjtree.clearNodeScope(jjtn000);
2875: jjtc000 = false;
2876: } else {
2877: jjtree.popNode();
2878: }
2879: if (jjte000 instanceof RuntimeException) {
2880: {
2881: if (true)
2882: throw (RuntimeException) jjte000;
2883: }
2884: }
2885: if (jjte000 instanceof ParseException) {
2886: {
2887: if (true)
2888: throw (ParseException) jjte000;
2889: }
2890: }
2891: {
2892: if (true)
2893: throw (Error) jjte000;
2894: }
2895: } finally {
2896: if (jjtc000) {
2897: jjtree.closeNodeScope(jjtn000, true);
2898: }
2899: }
2900: }
2901:
2902: final public void SameTerm() throws ParseException {
2903: /*@bgen(jjtree) SameTerm */
2904: ASTSameTerm jjtn000 = new ASTSameTerm(JJTSAMETERM);
2905: boolean jjtc000 = true;
2906: jjtree.openNodeScope(jjtn000);
2907: try {
2908: jj_consume_token(SAMETERM);
2909: jj_consume_token(LPAREN);
2910: Expression();
2911: jj_consume_token(COMMA);
2912: Expression();
2913: jj_consume_token(RPAREN);
2914: } catch (Throwable jjte000) {
2915: if (jjtc000) {
2916: jjtree.clearNodeScope(jjtn000);
2917: jjtc000 = false;
2918: } else {
2919: jjtree.popNode();
2920: }
2921: if (jjte000 instanceof RuntimeException) {
2922: {
2923: if (true)
2924: throw (RuntimeException) jjte000;
2925: }
2926: }
2927: if (jjte000 instanceof ParseException) {
2928: {
2929: if (true)
2930: throw (ParseException) jjte000;
2931: }
2932: }
2933: {
2934: if (true)
2935: throw (Error) jjte000;
2936: }
2937: } finally {
2938: if (jjtc000) {
2939: jjtree.closeNodeScope(jjtn000, true);
2940: }
2941: }
2942: }
2943:
2944: final public void IsIRI() throws ParseException {
2945: /*@bgen(jjtree) IsIRI */
2946: ASTIsIRI jjtn000 = new ASTIsIRI(JJTISIRI);
2947: boolean jjtc000 = true;
2948: jjtree.openNodeScope(jjtn000);
2949: try {
2950: jj_consume_token(IS_IRI);
2951: jj_consume_token(LPAREN);
2952: Expression();
2953: jj_consume_token(RPAREN);
2954: } catch (Throwable jjte000) {
2955: if (jjtc000) {
2956: jjtree.clearNodeScope(jjtn000);
2957: jjtc000 = false;
2958: } else {
2959: jjtree.popNode();
2960: }
2961: if (jjte000 instanceof RuntimeException) {
2962: {
2963: if (true)
2964: throw (RuntimeException) jjte000;
2965: }
2966: }
2967: if (jjte000 instanceof ParseException) {
2968: {
2969: if (true)
2970: throw (ParseException) jjte000;
2971: }
2972: }
2973: {
2974: if (true)
2975: throw (Error) jjte000;
2976: }
2977: } finally {
2978: if (jjtc000) {
2979: jjtree.closeNodeScope(jjtn000, true);
2980: }
2981: }
2982: }
2983:
2984: final public void IsBlank() throws ParseException {
2985: /*@bgen(jjtree) IsBlank */
2986: ASTIsBlank jjtn000 = new ASTIsBlank(JJTISBLANK);
2987: boolean jjtc000 = true;
2988: jjtree.openNodeScope(jjtn000);
2989: try {
2990: jj_consume_token(IS_BLANK);
2991: jj_consume_token(LPAREN);
2992: Expression();
2993: jj_consume_token(RPAREN);
2994: } catch (Throwable jjte000) {
2995: if (jjtc000) {
2996: jjtree.clearNodeScope(jjtn000);
2997: jjtc000 = false;
2998: } else {
2999: jjtree.popNode();
3000: }
3001: if (jjte000 instanceof RuntimeException) {
3002: {
3003: if (true)
3004: throw (RuntimeException) jjte000;
3005: }
3006: }
3007: if (jjte000 instanceof ParseException) {
3008: {
3009: if (true)
3010: throw (ParseException) jjte000;
3011: }
3012: }
3013: {
3014: if (true)
3015: throw (Error) jjte000;
3016: }
3017: } finally {
3018: if (jjtc000) {
3019: jjtree.closeNodeScope(jjtn000, true);
3020: }
3021: }
3022: }
3023:
3024: final public void IsLiteral() throws ParseException {
3025: /*@bgen(jjtree) IsLiteral */
3026: ASTIsLiteral jjtn000 = new ASTIsLiteral(JJTISLITERAL);
3027: boolean jjtc000 = true;
3028: jjtree.openNodeScope(jjtn000);
3029: try {
3030: jj_consume_token(IS_LITERAL);
3031: jj_consume_token(LPAREN);
3032: Expression();
3033: jj_consume_token(RPAREN);
3034: } catch (Throwable jjte000) {
3035: if (jjtc000) {
3036: jjtree.clearNodeScope(jjtn000);
3037: jjtc000 = false;
3038: } else {
3039: jjtree.popNode();
3040: }
3041: if (jjte000 instanceof RuntimeException) {
3042: {
3043: if (true)
3044: throw (RuntimeException) jjte000;
3045: }
3046: }
3047: if (jjte000 instanceof ParseException) {
3048: {
3049: if (true)
3050: throw (ParseException) jjte000;
3051: }
3052: }
3053: {
3054: if (true)
3055: throw (Error) jjte000;
3056: }
3057: } finally {
3058: if (jjtc000) {
3059: jjtree.closeNodeScope(jjtn000, true);
3060: }
3061: }
3062: }
3063:
3064: final public void RegexExpression() throws ParseException {
3065: /*@bgen(jjtree) RegexExpression */
3066: ASTRegexExpression jjtn000 = new ASTRegexExpression(
3067: JJTREGEXEXPRESSION);
3068: boolean jjtc000 = true;
3069: jjtree.openNodeScope(jjtn000);
3070: try {
3071: jj_consume_token(REGEX);
3072: jj_consume_token(LPAREN);
3073: Expression();
3074: jj_consume_token(COMMA);
3075: Expression();
3076: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3077: case COMMA:
3078: jj_consume_token(COMMA);
3079: Expression();
3080: break;
3081: default:
3082: jj_la1[72] = jj_gen;
3083: ;
3084: }
3085: jj_consume_token(RPAREN);
3086: } catch (Throwable jjte000) {
3087: if (jjtc000) {
3088: jjtree.clearNodeScope(jjtn000);
3089: jjtc000 = false;
3090: } else {
3091: jjtree.popNode();
3092: }
3093: if (jjte000 instanceof RuntimeException) {
3094: {
3095: if (true)
3096: throw (RuntimeException) jjte000;
3097: }
3098: }
3099: if (jjte000 instanceof ParseException) {
3100: {
3101: if (true)
3102: throw (ParseException) jjte000;
3103: }
3104: }
3105: {
3106: if (true)
3107: throw (Error) jjte000;
3108: }
3109: } finally {
3110: if (jjtc000) {
3111: jjtree.closeNodeScope(jjtn000, true);
3112: }
3113: }
3114: }
3115:
3116: final public void RDFLiteral() throws ParseException {
3117: /*@bgen(jjtree) RDFLiteral */
3118: ASTRDFLiteral jjtn000 = new ASTRDFLiteral(JJTRDFLITERAL);
3119: boolean jjtc000 = true;
3120: jjtree.openNodeScope(jjtn000);
3121: Token t;
3122: try {
3123: String();
3124: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3125: case DT_PREFIX:
3126: case LANGTAG:
3127: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3128: case LANGTAG:
3129: t = jj_consume_token(LANGTAG);
3130: jjtn000.setLang(t.image.substring(1));
3131: break;
3132: case DT_PREFIX:
3133: jj_consume_token(DT_PREFIX);
3134: IRIref();
3135: break;
3136: default:
3137: jj_la1[73] = jj_gen;
3138: jj_consume_token(-1);
3139: throw new ParseException();
3140: }
3141: break;
3142: default:
3143: jj_la1[74] = jj_gen;
3144: ;
3145: }
3146: } catch (Throwable jjte000) {
3147: if (jjtc000) {
3148: jjtree.clearNodeScope(jjtn000);
3149: jjtc000 = false;
3150: } else {
3151: jjtree.popNode();
3152: }
3153: if (jjte000 instanceof RuntimeException) {
3154: {
3155: if (true)
3156: throw (RuntimeException) jjte000;
3157: }
3158: }
3159: if (jjte000 instanceof ParseException) {
3160: {
3161: if (true)
3162: throw (ParseException) jjte000;
3163: }
3164: }
3165: {
3166: if (true)
3167: throw (Error) jjte000;
3168: }
3169: } finally {
3170: if (jjtc000) {
3171: jjtree.closeNodeScope(jjtn000, true);
3172: }
3173: }
3174: }
3175:
3176: final public void NumericLiteral() throws ParseException {
3177: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3178: case INTEGER:
3179: case DECIMAL:
3180: case DOUBLE:
3181: NumericLiteralUnsigned();
3182: break;
3183: case INTEGER_POSITIVE:
3184: case DECIMAL_POSITIVE:
3185: case DOUBLE_POSITIVE:
3186: NumericLiteralPositive();
3187: break;
3188: case INTEGER_NEGATIVE:
3189: case DECIMAL_NEGATIVE:
3190: case DOUBLE_NEGATIVE:
3191: NumericLiteralNegative();
3192: break;
3193: default:
3194: jj_la1[75] = jj_gen;
3195: jj_consume_token(-1);
3196: throw new ParseException();
3197: }
3198: }
3199:
3200: final public void NumericLiteralUnsigned() throws ParseException {
3201: /*@bgen(jjtree) NumericLiteral */
3202: ASTNumericLiteral jjtn000 = new ASTNumericLiteral(
3203: JJTNUMERICLITERAL);
3204: boolean jjtc000 = true;
3205: jjtree.openNodeScope(jjtn000);
3206: Token t;
3207: URI datatype;
3208: try {
3209: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3210: case INTEGER:
3211: t = jj_consume_token(INTEGER);
3212: datatype = XMLSchema.INTEGER;
3213: break;
3214: case DECIMAL:
3215: t = jj_consume_token(DECIMAL);
3216: datatype = XMLSchema.DECIMAL;
3217: break;
3218: case DOUBLE:
3219: t = jj_consume_token(DOUBLE);
3220: datatype = XMLSchema.DOUBLE;
3221: break;
3222: default:
3223: jj_la1[76] = jj_gen;
3224: jj_consume_token(-1);
3225: throw new ParseException();
3226: }
3227: jjtree.closeNodeScope(jjtn000, true);
3228: jjtc000 = false;
3229: jjtn000.setValue(t.image);
3230: jjtn000.setDatatype(datatype);
3231: } finally {
3232: if (jjtc000) {
3233: jjtree.closeNodeScope(jjtn000, true);
3234: }
3235: }
3236: }
3237:
3238: final public void NumericLiteralPositive() throws ParseException {
3239: /*@bgen(jjtree) NumericLiteral */
3240: ASTNumericLiteral jjtn000 = new ASTNumericLiteral(
3241: JJTNUMERICLITERAL);
3242: boolean jjtc000 = true;
3243: jjtree.openNodeScope(jjtn000);
3244: Token t;
3245: URI datatype;
3246: try {
3247: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3248: case INTEGER_POSITIVE:
3249: t = jj_consume_token(INTEGER_POSITIVE);
3250: datatype = XMLSchema.INTEGER;
3251: break;
3252: case DECIMAL_POSITIVE:
3253: t = jj_consume_token(DECIMAL_POSITIVE);
3254: datatype = XMLSchema.DECIMAL;
3255: break;
3256: case DOUBLE_POSITIVE:
3257: t = jj_consume_token(DOUBLE_POSITIVE);
3258: datatype = XMLSchema.DOUBLE;
3259: break;
3260: default:
3261: jj_la1[77] = jj_gen;
3262: jj_consume_token(-1);
3263: throw new ParseException();
3264: }
3265: jjtree.closeNodeScope(jjtn000, true);
3266: jjtc000 = false;
3267: jjtn000.setValue(t.image);
3268: jjtn000.setDatatype(datatype);
3269: } finally {
3270: if (jjtc000) {
3271: jjtree.closeNodeScope(jjtn000, true);
3272: }
3273: }
3274: }
3275:
3276: final public void NumericLiteralNegative() throws ParseException {
3277: /*@bgen(jjtree) NumericLiteral */
3278: ASTNumericLiteral jjtn000 = new ASTNumericLiteral(
3279: JJTNUMERICLITERAL);
3280: boolean jjtc000 = true;
3281: jjtree.openNodeScope(jjtn000);
3282: Token t;
3283: URI datatype;
3284: try {
3285: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3286: case INTEGER_NEGATIVE:
3287: t = jj_consume_token(INTEGER_NEGATIVE);
3288: datatype = XMLSchema.INTEGER;
3289: break;
3290: case DECIMAL_NEGATIVE:
3291: t = jj_consume_token(DECIMAL_NEGATIVE);
3292: datatype = XMLSchema.DECIMAL;
3293: break;
3294: case DOUBLE_NEGATIVE:
3295: t = jj_consume_token(DOUBLE_NEGATIVE);
3296: datatype = XMLSchema.DOUBLE;
3297: break;
3298: default:
3299: jj_la1[78] = jj_gen;
3300: jj_consume_token(-1);
3301: throw new ParseException();
3302: }
3303: jjtree.closeNodeScope(jjtn000, true);
3304: jjtc000 = false;
3305: jjtn000.setValue(t.image);
3306: jjtn000.setDatatype(datatype);
3307: } finally {
3308: if (jjtc000) {
3309: jjtree.closeNodeScope(jjtn000, true);
3310: }
3311: }
3312: }
3313:
3314: final public void BooleanLiteral() throws ParseException {
3315: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3316: case TRUE:
3317: ASTTrue jjtn001 = new ASTTrue(JJTTRUE);
3318: boolean jjtc001 = true;
3319: jjtree.openNodeScope(jjtn001);
3320: try {
3321: jj_consume_token(TRUE);
3322: } finally {
3323: if (jjtc001) {
3324: jjtree.closeNodeScope(jjtn001, true);
3325: }
3326: }
3327: break;
3328: case FALSE:
3329: ASTFalse jjtn002 = new ASTFalse(JJTFALSE);
3330: boolean jjtc002 = true;
3331: jjtree.openNodeScope(jjtn002);
3332: try {
3333: jj_consume_token(FALSE);
3334: } finally {
3335: if (jjtc002) {
3336: jjtree.closeNodeScope(jjtn002, true);
3337: }
3338: }
3339: break;
3340: default:
3341: jj_la1[79] = jj_gen;
3342: jj_consume_token(-1);
3343: throw new ParseException();
3344: }
3345: }
3346:
3347: final public void String() throws ParseException {
3348: /*@bgen(jjtree) String */
3349: ASTString jjtn000 = new ASTString(JJTSTRING);
3350: boolean jjtc000 = true;
3351: jjtree.openNodeScope(jjtn000);
3352: Token t;
3353: try {
3354: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3355: case STRING_LITERAL1:
3356: case STRING_LITERAL2:
3357: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3358: case STRING_LITERAL1:
3359: t = jj_consume_token(STRING_LITERAL1);
3360: break;
3361: case STRING_LITERAL2:
3362: t = jj_consume_token(STRING_LITERAL2);
3363: break;
3364: default:
3365: jj_la1[80] = jj_gen;
3366: jj_consume_token(-1);
3367: throw new ParseException();
3368: }
3369: jjtree.closeNodeScope(jjtn000, true);
3370: jjtc000 = false;
3371: jjtn000.setValue(_trimString(t.image, 1));
3372: break;
3373: case STRING_LITERAL_LONG1:
3374: case STRING_LITERAL_LONG2:
3375: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3376: case STRING_LITERAL_LONG1:
3377: t = jj_consume_token(STRING_LITERAL_LONG1);
3378: break;
3379: case STRING_LITERAL_LONG2:
3380: t = jj_consume_token(STRING_LITERAL_LONG2);
3381: break;
3382: default:
3383: jj_la1[81] = jj_gen;
3384: jj_consume_token(-1);
3385: throw new ParseException();
3386: }
3387: jjtree.closeNodeScope(jjtn000, true);
3388: jjtc000 = false;
3389: jjtn000.setValue(_trimString(t.image, 3));
3390: break;
3391: default:
3392: jj_la1[82] = jj_gen;
3393: jj_consume_token(-1);
3394: throw new ParseException();
3395: }
3396: } finally {
3397: if (jjtc000) {
3398: jjtree.closeNodeScope(jjtn000, true);
3399: }
3400: }
3401: }
3402:
3403: final public void IRIref() throws ParseException {
3404: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3405: case Q_IRI_REF:
3406: IRI();
3407: break;
3408: case PNAME_NS:
3409: case PNAME_LN:
3410: PrefixedName();
3411: break;
3412: default:
3413: jj_la1[83] = jj_gen;
3414: jj_consume_token(-1);
3415: throw new ParseException();
3416: }
3417: }
3418:
3419: final public void PrefixedName() throws ParseException {
3420: /*@bgen(jjtree) QName */
3421: ASTQName jjtn000 = new ASTQName(JJTQNAME);
3422: boolean jjtc000 = true;
3423: jjtree.openNodeScope(jjtn000);
3424: Token t;
3425: try {
3426: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3427: case PNAME_LN:
3428: t = jj_consume_token(PNAME_LN);
3429: break;
3430: case PNAME_NS:
3431: t = jj_consume_token(PNAME_NS);
3432: break;
3433: default:
3434: jj_la1[84] = jj_gen;
3435: jj_consume_token(-1);
3436: throw new ParseException();
3437: }
3438: jjtree.closeNodeScope(jjtn000, true);
3439: jjtc000 = false;
3440: jjtn000.setValue(t.image);
3441: } finally {
3442: if (jjtc000) {
3443: jjtree.closeNodeScope(jjtn000, true);
3444: }
3445: }
3446: }
3447:
3448: final public void BlankNode() throws ParseException {
3449: /*@bgen(jjtree) BlankNode */
3450: ASTBlankNode jjtn000 = new ASTBlankNode(JJTBLANKNODE);
3451: boolean jjtc000 = true;
3452: jjtree.openNodeScope(jjtn000);
3453: Token t;
3454: try {
3455: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3456: case BLANK_NODE_LABEL:
3457: t = jj_consume_token(BLANK_NODE_LABEL);
3458: jjtree.closeNodeScope(jjtn000, true);
3459: jjtc000 = false;
3460: jjtn000.setID(t.image.substring(2));
3461: break;
3462: case ANON:
3463: jj_consume_token(ANON);
3464: break;
3465: default:
3466: jj_la1[85] = jj_gen;
3467: jj_consume_token(-1);
3468: throw new ParseException();
3469: }
3470: } finally {
3471: if (jjtc000) {
3472: jjtree.closeNodeScope(jjtn000, true);
3473: }
3474: }
3475: }
3476:
3477: final public void IRI() throws ParseException {
3478: /*@bgen(jjtree) IRI */
3479: ASTIRI jjtn000 = new ASTIRI(JJTIRI);
3480: boolean jjtc000 = true;
3481: jjtree.openNodeScope(jjtn000);
3482: Token t;
3483: try {
3484: t = jj_consume_token(Q_IRI_REF);
3485: jjtree.closeNodeScope(jjtn000, true);
3486: jjtc000 = false;
3487: jjtn000.setValue(_trimString(t.image, 1));
3488: } finally {
3489: if (jjtc000) {
3490: jjtree.closeNodeScope(jjtn000, true);
3491: }
3492: }
3493: }
3494:
3495: final private boolean jj_2_1(int xla) {
3496: jj_la = xla;
3497: jj_lastpos = jj_scanpos = token;
3498: try {
3499: return !jj_3_1();
3500: } catch (LookaheadSuccess ls) {
3501: return true;
3502: } finally {
3503: jj_save(0, xla);
3504: }
3505: }
3506:
3507: final private boolean jj_2_2(int xla) {
3508: jj_la = xla;
3509: jj_lastpos = jj_scanpos = token;
3510: try {
3511: return !jj_3_2();
3512: } catch (LookaheadSuccess ls) {
3513: return true;
3514: } finally {
3515: jj_save(1, xla);
3516: }
3517: }
3518:
3519: final private boolean jj_3R_41() {
3520: if (jj_3R_46())
3521: return true;
3522: return false;
3523: }
3524:
3525: final private boolean jj_3R_44() {
3526: if (jj_3R_48())
3527: return true;
3528: return false;
3529: }
3530:
3531: final private boolean jj_3R_40() {
3532: if (jj_3R_45())
3533: return true;
3534: return false;
3535: }
3536:
3537: final private boolean jj_3R_27() {
3538: if (jj_scan_token(LPAREN))
3539: return true;
3540: return false;
3541: }
3542:
3543: final private boolean jj_3R_39() {
3544: if (jj_3R_44())
3545: return true;
3546: return false;
3547: }
3548:
3549: final private boolean jj_3R_33() {
3550: Token xsp;
3551: xsp = jj_scanpos;
3552: if (jj_scan_token(65)) {
3553: jj_scanpos = xsp;
3554: if (jj_scan_token(64))
3555: return true;
3556: }
3557: return false;
3558: }
3559:
3560: final private boolean jj_3R_22() {
3561: Token xsp;
3562: xsp = jj_scanpos;
3563: if (jj_scan_token(27)) {
3564: jj_scanpos = xsp;
3565: if (jj_3R_27())
3566: return true;
3567: }
3568: return false;
3569: }
3570:
3571: final private boolean jj_3R_35() {
3572: Token xsp;
3573: xsp = jj_scanpos;
3574: if (jj_3R_38()) {
3575: jj_scanpos = xsp;
3576: if (jj_3R_39()) {
3577: jj_scanpos = xsp;
3578: if (jj_3R_40()) {
3579: jj_scanpos = xsp;
3580: if (jj_3R_41()) {
3581: jj_scanpos = xsp;
3582: if (jj_3R_42()) {
3583: jj_scanpos = xsp;
3584: if (jj_3R_43())
3585: return true;
3586: }
3587: }
3588: }
3589: }
3590: }
3591: return false;
3592: }
3593:
3594: final private boolean jj_3R_38() {
3595: if (jj_3R_21())
3596: return true;
3597: return false;
3598: }
3599:
3600: final private boolean jj_3R_26() {
3601: if (jj_3R_33())
3602: return true;
3603: return false;
3604: }
3605:
3606: final private boolean jj_3R_18() {
3607: if (jj_3R_21())
3608: return true;
3609: if (jj_3R_22())
3610: return true;
3611: return false;
3612: }
3613:
3614: final private boolean jj_3R_25() {
3615: if (jj_3R_32())
3616: return true;
3617: return false;
3618: }
3619:
3620: final private boolean jj_3R_21() {
3621: Token xsp;
3622: xsp = jj_scanpos;
3623: if (jj_3R_25()) {
3624: jj_scanpos = xsp;
3625: if (jj_3R_26())
3626: return true;
3627: }
3628: return false;
3629: }
3630:
3631: final private boolean jj_3R_34() {
3632: Token xsp;
3633: xsp = jj_scanpos;
3634: if (jj_scan_token(67)) {
3635: jj_scanpos = xsp;
3636: if (jj_scan_token(68))
3637: return true;
3638: }
3639: return false;
3640: }
3641:
3642: final private boolean jj_3R_56() {
3643: Token xsp;
3644: xsp = jj_scanpos;
3645: if (jj_scan_token(87)) {
3646: jj_scanpos = xsp;
3647: if (jj_scan_token(88))
3648: return true;
3649: }
3650: return false;
3651: }
3652:
3653: final private boolean jj_3R_55() {
3654: Token xsp;
3655: xsp = jj_scanpos;
3656: if (jj_scan_token(85)) {
3657: jj_scanpos = xsp;
3658: if (jj_scan_token(86))
3659: return true;
3660: }
3661: return false;
3662: }
3663:
3664: final private boolean jj_3R_48() {
3665: Token xsp;
3666: xsp = jj_scanpos;
3667: if (jj_3R_55()) {
3668: jj_scanpos = xsp;
3669: if (jj_3R_56())
3670: return true;
3671: }
3672: return false;
3673: }
3674:
3675: final private boolean jj_3R_53() {
3676: if (jj_scan_token(FALSE))
3677: return true;
3678: return false;
3679: }
3680:
3681: final private boolean jj_3R_52() {
3682: if (jj_scan_token(TRUE))
3683: return true;
3684: return false;
3685: }
3686:
3687: final private boolean jj_3R_29() {
3688: if (jj_3R_35())
3689: return true;
3690: return false;
3691: }
3692:
3693: final private boolean jj_3R_46() {
3694: Token xsp;
3695: xsp = jj_scanpos;
3696: if (jj_3R_52()) {
3697: jj_scanpos = xsp;
3698: if (jj_3R_53())
3699: return true;
3700: }
3701: return false;
3702: }
3703:
3704: final private boolean jj_3R_28() {
3705: if (jj_3R_34())
3706: return true;
3707: return false;
3708: }
3709:
3710: final private boolean jj_3R_23() {
3711: Token xsp;
3712: xsp = jj_scanpos;
3713: if (jj_3R_28()) {
3714: jj_scanpos = xsp;
3715: if (jj_3R_29())
3716: return true;
3717: }
3718: return false;
3719: }
3720:
3721: final private boolean jj_3R_68() {
3722: if (jj_scan_token(DOUBLE_NEGATIVE))
3723: return true;
3724: return false;
3725: }
3726:
3727: final private boolean jj_3R_67() {
3728: if (jj_scan_token(DECIMAL_NEGATIVE))
3729: return true;
3730: return false;
3731: }
3732:
3733: final private boolean jj_3R_66() {
3734: if (jj_scan_token(INTEGER_NEGATIVE))
3735: return true;
3736: return false;
3737: }
3738:
3739: final private boolean jj_3_1() {
3740: if (jj_scan_token(DOT))
3741: return true;
3742: if (jj_3R_17())
3743: return true;
3744: return false;
3745: }
3746:
3747: final private boolean jj_3R_59() {
3748: Token xsp;
3749: xsp = jj_scanpos;
3750: if (jj_3R_66()) {
3751: jj_scanpos = xsp;
3752: if (jj_3R_67()) {
3753: jj_scanpos = xsp;
3754: if (jj_3R_68())
3755: return true;
3756: }
3757: }
3758: return false;
3759: }
3760:
3761: final private boolean jj_3R_36() {
3762: if (jj_scan_token(LPAREN))
3763: return true;
3764: return false;
3765: }
3766:
3767: final private boolean jj_3R_65() {
3768: if (jj_scan_token(DOUBLE_POSITIVE))
3769: return true;
3770: return false;
3771: }
3772:
3773: final private boolean jj_3R_64() {
3774: if (jj_scan_token(DECIMAL_POSITIVE))
3775: return true;
3776: return false;
3777: }
3778:
3779: final private boolean jj_3R_63() {
3780: if (jj_scan_token(INTEGER_POSITIVE))
3781: return true;
3782: return false;
3783: }
3784:
3785: final private boolean jj_3R_37() {
3786: if (jj_scan_token(LBRACK))
3787: return true;
3788: return false;
3789: }
3790:
3791: final private boolean jj_3R_31() {
3792: if (jj_3R_37())
3793: return true;
3794: return false;
3795: }
3796:
3797: final private boolean jj_3R_58() {
3798: Token xsp;
3799: xsp = jj_scanpos;
3800: if (jj_3R_63()) {
3801: jj_scanpos = xsp;
3802: if (jj_3R_64()) {
3803: jj_scanpos = xsp;
3804: if (jj_3R_65())
3805: return true;
3806: }
3807: }
3808: return false;
3809: }
3810:
3811: final private boolean jj_3R_30() {
3812: if (jj_3R_36())
3813: return true;
3814: return false;
3815: }
3816:
3817: final private boolean jj_3R_24() {
3818: Token xsp;
3819: xsp = jj_scanpos;
3820: if (jj_3R_30()) {
3821: jj_scanpos = xsp;
3822: if (jj_3R_31())
3823: return true;
3824: }
3825: return false;
3826: }
3827:
3828: final private boolean jj_3R_62() {
3829: if (jj_scan_token(DOUBLE))
3830: return true;
3831: return false;
3832: }
3833:
3834: final private boolean jj_3R_61() {
3835: if (jj_scan_token(DECIMAL))
3836: return true;
3837: return false;
3838: }
3839:
3840: final private boolean jj_3R_60() {
3841: if (jj_scan_token(INTEGER))
3842: return true;
3843: return false;
3844: }
3845:
3846: final private boolean jj_3R_51() {
3847: if (jj_3R_59())
3848: return true;
3849: return false;
3850: }
3851:
3852: final private boolean jj_3R_57() {
3853: Token xsp;
3854: xsp = jj_scanpos;
3855: if (jj_3R_60()) {
3856: jj_scanpos = xsp;
3857: if (jj_3R_61()) {
3858: jj_scanpos = xsp;
3859: if (jj_3R_62())
3860: return true;
3861: }
3862: }
3863: return false;
3864: }
3865:
3866: final private boolean jj_3R_50() {
3867: if (jj_3R_58())
3868: return true;
3869: return false;
3870: }
3871:
3872: final private boolean jj_3R_49() {
3873: if (jj_3R_57())
3874: return true;
3875: return false;
3876: }
3877:
3878: final private boolean jj_3R_45() {
3879: Token xsp;
3880: xsp = jj_scanpos;
3881: if (jj_3R_49()) {
3882: jj_scanpos = xsp;
3883: if (jj_3R_50()) {
3884: jj_scanpos = xsp;
3885: if (jj_3R_51())
3886: return true;
3887: }
3888: }
3889: return false;
3890: }
3891:
3892: final private boolean jj_3R_32() {
3893: if (jj_scan_token(Q_IRI_REF))
3894: return true;
3895: return false;
3896: }
3897:
3898: final private boolean jj_3R_20() {
3899: if (jj_3R_24())
3900: return true;
3901: return false;
3902: }
3903:
3904: final private boolean jj_3R_43() {
3905: if (jj_scan_token(NIL))
3906: return true;
3907: return false;
3908: }
3909:
3910: final private boolean jj_3R_54() {
3911: if (jj_scan_token(BLANK_NODE_LABEL))
3912: return true;
3913: return false;
3914: }
3915:
3916: final private boolean jj_3_2() {
3917: if (jj_3R_18())
3918: return true;
3919: return false;
3920: }
3921:
3922: final private boolean jj_3R_47() {
3923: Token xsp;
3924: xsp = jj_scanpos;
3925: if (jj_3R_54()) {
3926: jj_scanpos = xsp;
3927: if (jj_scan_token(28))
3928: return true;
3929: }
3930: return false;
3931: }
3932:
3933: final private boolean jj_3R_17() {
3934: Token xsp;
3935: xsp = jj_scanpos;
3936: if (jj_3R_19()) {
3937: jj_scanpos = xsp;
3938: if (jj_3R_20())
3939: return true;
3940: }
3941: return false;
3942: }
3943:
3944: final private boolean jj_3R_19() {
3945: if (jj_3R_23())
3946: return true;
3947: return false;
3948: }
3949:
3950: final private boolean jj_3R_42() {
3951: if (jj_3R_47())
3952: return true;
3953: return false;
3954: }
3955:
3956: public SyntaxTreeBuilderTokenManager token_source;
3957: JavaCharStream jj_input_stream;
3958: public Token token, jj_nt;
3959: private int jj_ntk;
3960: private Token jj_scanpos, jj_lastpos;
3961: private int jj_la;
3962: public boolean lookingAhead = false;
3963: private boolean jj_semLA;
3964: private int jj_gen;
3965: final private int[] jj_la1 = new int[86];
3966: static private int[] jj_la1_0;
3967: static private int[] jj_la1_1;
3968: static private int[] jj_la1_2;
3969: static private int[] jj_la1_3;
3970: static {
3971: jj_la1_0();
3972: jj_la1_1();
3973: jj_la1_2();
3974: jj_la1_3();
3975: }
3976:
3977: private static void jj_la1_0() {
3978: jj_la1_0 = new int[] { 0x40000000, 0x80000000, 0x0, 0x0, 0x0,
3979: 0x0, 0x0, 0x0, 0x0, 0x1000000, 0x0, 0x0, 0x0,
3980: 0x18000110, 0x0, 0x40, 0x0, 0x0, 0x0, 0x1000000, 0x0,
3981: 0x0, 0x0, 0x10, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0,
3982: 0x18000110, 0x1000, 0x40, 0x0, 0x1000, 0x18000110,
3983: 0x1000, 0x18000110, 0x0, 0x18000110, 0x1000, 0x40, 0x0,
3984: 0x10, 0x800, 0x8000010, 0x20000000, 0x18000110,
3985: 0x20000000, 0x400, 0x800, 0x20000000, 0x110,
3986: 0x18000110, 0x18000110, 0x18000000, 0x0, 0x0,
3987: 0x18000000, 0x100000, 0x200000, 0x7e000, 0x7e000,
3988: 0xc00000, 0xc00000, 0x3000000, 0x3000000, 0x400000,
3989: 0xc80010, 0x10, 0x0, 0x0, 0x800, 0x4000000, 0x4000000,
3990: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3991: 0x10000000, };
3992: }
3993:
3994: private static void jj_la1_1() {
3995: jj_la1_1 = new int[] { 0x0, 0x0, 0xf, 0x40, 0x200, 0x6000,
3996: 0x30, 0x30, 0x0, 0x0, 0x40, 0x200, 0x6000, 0xe0000000,
3997: 0x40, 0x100, 0x200, 0x6000, 0x80000000, 0x80000000,
3998: 0x40, 0x80, 0x100, 0x9ff81800, 0x1800, 0x1800,
3999: 0x9ff81800, 0x4000, 0x2000, 0x6000, 0xe0040000, 0x0,
4000: 0x18000, 0x40000, 0x0, 0xe0000000, 0x0, 0xe0000000,
4001: 0x40000, 0xe0040000, 0x0, 0x18000, 0x20000, 0x9ff80000,
4002: 0x0, 0x0, 0x80000000, 0xe0000000, 0x80000000, 0x0, 0x0,
4003: 0x80000000, 0x0, 0xe0000000, 0xe0000000, 0xe0000000,
4004: 0x80000000, 0x0, 0xe0000000, 0x0, 0x0, 0x0, 0x0, 0x0,
4005: 0x0, 0x0, 0x0, 0x0, 0xfff80000, 0x1ff80000, 0xe0000000,
4006: 0x1ff80000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4007: 0x60000000, 0x0, 0x0, 0x0, 0x80000000, 0x0, 0x0, };
4008: }
4009:
4010: private static void jj_la1_2() {
4011: jj_la1_2 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4012: 0x18, 0x18, 0x0, 0x0, 0x0, 0x1f873df, 0x0, 0x0, 0x0,
4013: 0x0, 0x1b, 0x1b, 0x0, 0x0, 0x0, 0x1b, 0x0, 0x0, 0x1b,
4014: 0x0, 0x0, 0x0, 0x1f873df, 0x0, 0x0, 0x0, 0x0,
4015: 0x1f873df, 0x0, 0x1f873df, 0x0, 0x1f873df, 0x0, 0x0,
4016: 0x0, 0x3, 0x0, 0x0, 0x1b, 0x1f873df, 0x1b, 0x0, 0x0,
4017: 0x1b, 0x0, 0x1f873df, 0x1f873df, 0x1f873df, 0x1b, 0x18,
4018: 0x1f873c7, 0x0, 0x0, 0x0, 0x0, 0x183180, 0x183180, 0x0,
4019: 0x0, 0x0, 0x1f873db, 0x0, 0x1f873db, 0x0, 0x0, 0x20,
4020: 0x20, 0x1873c0, 0x4240, 0x81080, 0x102100, 0x0,
4021: 0x600000, 0x1800000, 0x1e00000, 0x3, 0x3, 0x4, };
4022: }
4023:
4024: private static void jj_la1_3() {
4025: jj_la1_3 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4026: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4027: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4028: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4029: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4030: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4031: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4032: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4033: 0x0, };
4034: }
4035:
4036: final private JJCalls[] jj_2_rtns = new JJCalls[2];
4037: private boolean jj_rescan = false;
4038: private int jj_gc = 0;
4039:
4040: public SyntaxTreeBuilder(java.io.InputStream stream) {
4041: this (stream, null);
4042: }
4043:
4044: public SyntaxTreeBuilder(java.io.InputStream stream, String encoding) {
4045: try {
4046: jj_input_stream = new JavaCharStream(stream, encoding, 1, 1);
4047: } catch (java.io.UnsupportedEncodingException e) {
4048: throw new RuntimeException(e);
4049: }
4050: token_source = new SyntaxTreeBuilderTokenManager(
4051: jj_input_stream);
4052: token = new Token();
4053: jj_ntk = -1;
4054: jj_gen = 0;
4055: for (int i = 0; i < 86; i++)
4056: jj_la1[i] = -1;
4057: for (int i = 0; i < jj_2_rtns.length; i++)
4058: jj_2_rtns[i] = new JJCalls();
4059: }
4060:
4061: public void ReInit(java.io.InputStream stream) {
4062: ReInit(stream, null);
4063: }
4064:
4065: public void ReInit(java.io.InputStream stream, String encoding) {
4066: try {
4067: jj_input_stream.ReInit(stream, encoding, 1, 1);
4068: } catch (java.io.UnsupportedEncodingException e) {
4069: throw new RuntimeException(e);
4070: }
4071: token_source.ReInit(jj_input_stream);
4072: token = new Token();
4073: jj_ntk = -1;
4074: jjtree.reset();
4075: jj_gen = 0;
4076: for (int i = 0; i < 86; i++)
4077: jj_la1[i] = -1;
4078: for (int i = 0; i < jj_2_rtns.length; i++)
4079: jj_2_rtns[i] = new JJCalls();
4080: }
4081:
4082: public SyntaxTreeBuilder(java.io.Reader stream) {
4083: jj_input_stream = new JavaCharStream(stream, 1, 1);
4084: token_source = new SyntaxTreeBuilderTokenManager(
4085: jj_input_stream);
4086: token = new Token();
4087: jj_ntk = -1;
4088: jj_gen = 0;
4089: for (int i = 0; i < 86; i++)
4090: jj_la1[i] = -1;
4091: for (int i = 0; i < jj_2_rtns.length; i++)
4092: jj_2_rtns[i] = new JJCalls();
4093: }
4094:
4095: public void ReInit(java.io.Reader stream) {
4096: jj_input_stream.ReInit(stream, 1, 1);
4097: token_source.ReInit(jj_input_stream);
4098: token = new Token();
4099: jj_ntk = -1;
4100: jjtree.reset();
4101: jj_gen = 0;
4102: for (int i = 0; i < 86; i++)
4103: jj_la1[i] = -1;
4104: for (int i = 0; i < jj_2_rtns.length; i++)
4105: jj_2_rtns[i] = new JJCalls();
4106: }
4107:
4108: public SyntaxTreeBuilder(SyntaxTreeBuilderTokenManager tm) {
4109: token_source = tm;
4110: token = new Token();
4111: jj_ntk = -1;
4112: jj_gen = 0;
4113: for (int i = 0; i < 86; i++)
4114: jj_la1[i] = -1;
4115: for (int i = 0; i < jj_2_rtns.length; i++)
4116: jj_2_rtns[i] = new JJCalls();
4117: }
4118:
4119: public void ReInit(SyntaxTreeBuilderTokenManager tm) {
4120: token_source = tm;
4121: token = new Token();
4122: jj_ntk = -1;
4123: jjtree.reset();
4124: jj_gen = 0;
4125: for (int i = 0; i < 86; i++)
4126: jj_la1[i] = -1;
4127: for (int i = 0; i < jj_2_rtns.length; i++)
4128: jj_2_rtns[i] = new JJCalls();
4129: }
4130:
4131: final private Token jj_consume_token(int kind)
4132: throws ParseException {
4133: Token oldToken;
4134: if ((oldToken = token).next != null)
4135: token = token.next;
4136: else
4137: token = token.next = token_source.getNextToken();
4138: jj_ntk = -1;
4139: if (token.kind == kind) {
4140: jj_gen++;
4141: if (++jj_gc > 100) {
4142: jj_gc = 0;
4143: for (int i = 0; i < jj_2_rtns.length; i++) {
4144: JJCalls c = jj_2_rtns[i];
4145: while (c != null) {
4146: if (c.gen < jj_gen)
4147: c.first = null;
4148: c = c.next;
4149: }
4150: }
4151: }
4152: return token;
4153: }
4154: token = oldToken;
4155: jj_kind = kind;
4156: throw generateParseException();
4157: }
4158:
4159: static private final class LookaheadSuccess extends java.lang.Error {
4160: }
4161:
4162: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
4163:
4164: final private boolean jj_scan_token(int kind) {
4165: if (jj_scanpos == jj_lastpos) {
4166: jj_la--;
4167: if (jj_scanpos.next == null) {
4168: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
4169: .getNextToken();
4170: } else {
4171: jj_lastpos = jj_scanpos = jj_scanpos.next;
4172: }
4173: } else {
4174: jj_scanpos = jj_scanpos.next;
4175: }
4176: if (jj_rescan) {
4177: int i = 0;
4178: Token tok = token;
4179: while (tok != null && tok != jj_scanpos) {
4180: i++;
4181: tok = tok.next;
4182: }
4183: if (tok != null)
4184: jj_add_error_token(kind, i);
4185: }
4186: if (jj_scanpos.kind != kind)
4187: return true;
4188: if (jj_la == 0 && jj_scanpos == jj_lastpos)
4189: throw jj_ls;
4190: return false;
4191: }
4192:
4193: final public Token getNextToken() {
4194: if (token.next != null)
4195: token = token.next;
4196: else
4197: token = token.next = token_source.getNextToken();
4198: jj_ntk = -1;
4199: jj_gen++;
4200: return token;
4201: }
4202:
4203: final public Token getToken(int index) {
4204: Token t = lookingAhead ? jj_scanpos : token;
4205: for (int i = 0; i < index; i++) {
4206: if (t.next != null)
4207: t = t.next;
4208: else
4209: t = t.next = token_source.getNextToken();
4210: }
4211: return t;
4212: }
4213:
4214: final private int jj_ntk() {
4215: if ((jj_nt = token.next) == null)
4216: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
4217: else
4218: return (jj_ntk = jj_nt.kind);
4219: }
4220:
4221: private java.util.Vector jj_expentries = new java.util.Vector();
4222: private int[] jj_expentry;
4223: private int jj_kind = -1;
4224: private int[] jj_lasttokens = new int[100];
4225: private int jj_endpos;
4226:
4227: private void jj_add_error_token(int kind, int pos) {
4228: if (pos >= 100)
4229: return;
4230: if (pos == jj_endpos + 1) {
4231: jj_lasttokens[jj_endpos++] = kind;
4232: } else if (jj_endpos != 0) {
4233: jj_expentry = new int[jj_endpos];
4234: for (int i = 0; i < jj_endpos; i++) {
4235: jj_expentry[i] = jj_lasttokens[i];
4236: }
4237: boolean exists = false;
4238: for (java.util.Enumeration e = jj_expentries.elements(); e
4239: .hasMoreElements();) {
4240: int[] oldentry = (int[]) (e.nextElement());
4241: if (oldentry.length == jj_expentry.length) {
4242: exists = true;
4243: for (int i = 0; i < jj_expentry.length; i++) {
4244: if (oldentry[i] != jj_expentry[i]) {
4245: exists = false;
4246: break;
4247: }
4248: }
4249: if (exists)
4250: break;
4251: }
4252: }
4253: if (!exists)
4254: jj_expentries.addElement(jj_expentry);
4255: if (pos != 0)
4256: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
4257: }
4258: }
4259:
4260: public ParseException generateParseException() {
4261: jj_expentries.removeAllElements();
4262: boolean[] la1tokens = new boolean[106];
4263: if (jj_kind >= 0) {
4264: la1tokens[jj_kind] = true;
4265: jj_kind = -1;
4266: }
4267: for (int i = 0; i < 86; i++) {
4268: if (jj_la1[i] == jj_gen) {
4269: for (int j = 0; j < 32; j++) {
4270: if ((jj_la1_0[i] & (1 << j)) != 0) {
4271: la1tokens[j] = true;
4272: }
4273: if ((jj_la1_1[i] & (1 << j)) != 0) {
4274: la1tokens[32 + j] = true;
4275: }
4276: if ((jj_la1_2[i] & (1 << j)) != 0) {
4277: la1tokens[64 + j] = true;
4278: }
4279: if ((jj_la1_3[i] & (1 << j)) != 0) {
4280: la1tokens[96 + j] = true;
4281: }
4282: }
4283: }
4284: }
4285: for (int i = 0; i < 106; i++) {
4286: if (la1tokens[i]) {
4287: jj_expentry = new int[1];
4288: jj_expentry[0] = i;
4289: jj_expentries.addElement(jj_expentry);
4290: }
4291: }
4292: jj_endpos = 0;
4293: jj_rescan_token();
4294: jj_add_error_token(0, 0);
4295: int[][] exptokseq = new int[jj_expentries.size()][];
4296: for (int i = 0; i < jj_expentries.size(); i++) {
4297: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
4298: }
4299: return new ParseException(token, exptokseq, tokenImage);
4300: }
4301:
4302: final public void enable_tracing() {
4303: }
4304:
4305: final public void disable_tracing() {
4306: }
4307:
4308: final private void jj_rescan_token() {
4309: jj_rescan = true;
4310: for (int i = 0; i < 2; i++) {
4311: try {
4312: JJCalls p = jj_2_rtns[i];
4313: do {
4314: if (p.gen > jj_gen) {
4315: jj_la = p.arg;
4316: jj_lastpos = jj_scanpos = p.first;
4317: switch (i) {
4318: case 0:
4319: jj_3_1();
4320: break;
4321: case 1:
4322: jj_3_2();
4323: break;
4324: }
4325: }
4326: p = p.next;
4327: } while (p != null);
4328: } catch (LookaheadSuccess ls) {
4329: }
4330: }
4331: jj_rescan = false;
4332: }
4333:
4334: final private void jj_save(int index, int xla) {
4335: JJCalls p = jj_2_rtns[index];
4336: while (p.gen > jj_gen) {
4337: if (p.next == null) {
4338: p = p.next = new JJCalls();
4339: break;
4340: }
4341: p = p.next;
4342: }
4343: p.gen = jj_gen + xla - jj_la;
4344: p.first = token;
4345: p.arg = xla;
4346: }
4347:
4348: static final class JJCalls {
4349: int gen;
4350: Token first;
4351: int arg;
4352: JJCalls next;
4353: }
4354:
4355: }
|