0001: /* Generated By:JavaCC: Do not edit this line. JDOQLParser.java */
0002: package com.versant.core.jdo.query;
0003:
0004: import com.versant.core.util.CharBuf;
0005: import com.versant.core.util.IntArray;
0006:
0007: import java.util.ArrayList;
0008:
0009: /**
0010: * JavaCC generated parser. Do not put a main method in this class as that
0011: * breaks obfuscation.
0012: */
0013: public class JDOQLParser implements JDOQLParserConstants {
0014:
0015: /**
0016: * Put method name to the method node
0017: * for example a.b.c() is FieldNavNode a, FieldNavNode b, FieldNode c and MethodNode () [ name = null ]
0018: * after this method a.b.c() becomes FieldNavNode a, FieldNode b MethodNode () [name = c ]
0019: * if the Primary expresssion resolves to a method only then that method is returned instead
0020: * of PrimaryExprNode this.
0021: */
0022:
0023: private void moveMethodName(MethodNode method) {
0024: Node left = method.childList;
0025: if (left == null) {
0026: return;
0027: }
0028: if (left instanceof FieldNode) {
0029: FieldNode f = (FieldNode) left;
0030: method.setName(f.lexeme);
0031: f.lexeme = "this";
0032: } else if (left instanceof FieldNavNode) {
0033: Node n = left, next = left.next;
0034: while (!(n.childList instanceof FieldNode))
0035: n = n.childList;
0036: FieldNode f = (FieldNode) n.childList;
0037: method.setName(f.lexeme);
0038:
0039: //Reset the FieldNode to it's parent
0040: f.lexeme = ((FieldNavNode) n).lexeme;
0041: f.parent = n.parent;
0042: n.parent.childList = f;
0043:
0044: //Reset next
0045: method.childList.next = next;
0046: }
0047:
0048: }
0049:
0050: public Node resolveMethod(Node node) {
0051: for (Node current = node.childList, previous = null; current != null;) {
0052: if (current.next instanceof MethodNode) {
0053: MethodNode currentMethod = (MethodNode) current.next;
0054:
0055: if (previous != null) {
0056: previous.next = currentMethod;
0057: } else {
0058: node.childList = currentMethod;
0059: }
0060: current.next = currentMethod.childList;
0061: currentMethod.childList = current;
0062: current.parent = currentMethod;
0063:
0064: moveMethodName(currentMethod);
0065:
0066: current = currentMethod;
0067: } else {
0068: previous = current;
0069: current = current.next;
0070: }
0071: }
0072:
0073: resolveMethod2(node);
0074: /*
0075: if(node.childList.next == null){
0076: return node.childList;
0077: }
0078: */
0079: return node;
0080: }
0081:
0082: public Node resolveMethod2(Node node) {
0083: for (Node current = node.childList, previous = null; current != null;) {
0084: if (current.next instanceof MethodNode) {
0085: MethodNode currentMethod = (MethodNode) current.next;
0086:
0087: if (previous != null) {
0088: previous.next = currentMethod;
0089: } else {
0090: node.childList = currentMethod;
0091: }
0092: current.next = (currentMethod.childList instanceof FieldNode && ((FieldNode) currentMethod.childList).lexeme
0093: .equals("this")) ? currentMethod.childList.next
0094: : currentMethod.childList;
0095:
0096: currentMethod.childList = current;
0097: current.parent = currentMethod;
0098:
0099: current = currentMethod;
0100: } else {
0101: previous = current;
0102: current = current.next;
0103: }
0104: }
0105:
0106: return node;
0107: }
0108:
0109: public static void main(String args[]) throws Exception {
0110: JDOQLParser parser = new JDOQLParser(System.in);
0111: System.out.println("Type some input and Ctrl-D to parse :");
0112: //parser.literal();
0113: //parser.type().dump(" ");
0114: parser.filterExpression().dump(" ");
0115: //Node nodes[] = parser.declareVariables();
0116: //Node nodes[] = parser.declareImports();
0117: //Node nodes[] = parser.setOrderings();
0118: /*Node nodes[] = parser.declareParameters();
0119: if(nodes != null){
0120: for(int i=0; i<nodes.length; i++){
0121: nodes[i].dump(">>>");
0122: System.out.println();
0123: }
0124: }*/
0125: }
0126:
0127: /**
0128: * Parameter declaration
0129: */
0130: final public ParamNode[] declareParameters() throws ParseException {
0131: ArrayList list = new ArrayList();
0132: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0133: case BOOLEAN:
0134: case BYTE:
0135: case CHAR:
0136: case DOUBLE:
0137: case FLOAT:
0138: case INT:
0139: case LONG:
0140: case SHORT:
0141: case IDENTIFIER:
0142: parameters(list);
0143: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0144: case COMMA:
0145: jj_consume_token(COMMA);
0146: break;
0147: default:
0148: jj_la1[0] = jj_gen;
0149: ;
0150: }
0151: jj_consume_token(0);
0152: int size = list.size();
0153: ParamNode[] params = new ParamNode[size];
0154: for (int i = 0; i < size; params[i] = (ParamNode) list
0155: .get(i++))
0156: ;
0157: {
0158: if (true)
0159: return params;
0160: }
0161: break;
0162: case 0:
0163: jj_consume_token(0);
0164: {
0165: if (true)
0166: return null;
0167: }
0168: break;
0169: default:
0170: jj_la1[1] = jj_gen;
0171: jj_consume_token(-1);
0172: throw new ParseException();
0173: }
0174: throw new Error("Missing return statement in function");
0175: }
0176:
0177: final public void parameters(ArrayList list) throws ParseException {
0178: ParamNode n;
0179: n = parameter();
0180: list.add(n);
0181: label_1: while (true) {
0182: if (jj_2_1(2)) {
0183: ;
0184: } else {
0185: break label_1;
0186: }
0187: jj_consume_token(COMMA);
0188: n = parameter();
0189: list.add(n);
0190: }
0191: }
0192:
0193: final public ParamNode parameter() throws ParseException {
0194: ParamNode n = new ParamNode();
0195: Token t;
0196: Object tp;
0197: tp = type();
0198: t = jj_consume_token(IDENTIFIER);
0199: if (tp instanceof Class)
0200: n.setCls((Class) tp);
0201: else
0202: n.setType((String) tp);
0203: n.setIdentifier(t.image);
0204: {
0205: if (true)
0206: return n;
0207: }
0208: throw new Error("Missing return statement in function");
0209: }
0210:
0211: /**
0212: * variable declaration
0213: */
0214: final public VarNode[] declareVariables() throws ParseException {
0215: ArrayList list = new ArrayList();
0216: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0217: case BOOLEAN:
0218: case BYTE:
0219: case CHAR:
0220: case DOUBLE:
0221: case FLOAT:
0222: case INT:
0223: case LONG:
0224: case SHORT:
0225: case IDENTIFIER:
0226: variables(list);
0227: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0228: case SEMICOLON:
0229: jj_consume_token(SEMICOLON);
0230: break;
0231: default:
0232: jj_la1[2] = jj_gen;
0233: ;
0234: }
0235: jj_consume_token(0);
0236: int size = list.size();
0237: VarNode[] Vars = new VarNode[size];
0238: for (int i = 0; i < size; Vars[i] = (VarNode) list.get(i++))
0239: ;
0240: {
0241: if (true)
0242: return Vars;
0243: }
0244: break;
0245: case 0:
0246: jj_consume_token(0);
0247: {
0248: if (true)
0249: return null;
0250: }
0251: break;
0252: default:
0253: jj_la1[3] = jj_gen;
0254: jj_consume_token(-1);
0255: throw new ParseException();
0256: }
0257: throw new Error("Missing return statement in function");
0258: }
0259:
0260: final public void variables(ArrayList list) throws ParseException {
0261: VarNode n;
0262: n = variable();
0263: list.add(n);
0264: label_2: while (true) {
0265: if (jj_2_2(2)) {
0266: ;
0267: } else {
0268: break label_2;
0269: }
0270: jj_consume_token(SEMICOLON);
0271: n = variable();
0272: list.add(n);
0273: }
0274: }
0275:
0276: final public VarNode variable() throws ParseException {
0277: VarNode n = new VarNode();
0278: Token t;
0279: Object tp;
0280: tp = type();
0281: t = jj_consume_token(IDENTIFIER);
0282: if (tp instanceof Class)
0283: n.setCls((Class) tp);
0284: else
0285: n.setType((String) tp);
0286: n.setIdentifier(t.image);
0287: {
0288: if (true)
0289: return n;
0290: }
0291: throw new Error("Missing return statement in function");
0292: }
0293:
0294: /**
0295: * Import declaration
0296: */
0297: final public ImportNode[] declareImports() throws ParseException {
0298: ArrayList list = new ArrayList();
0299: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0300: case IMPORT:
0301: importDeclarations(list);
0302: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0303: case SEMICOLON:
0304: jj_consume_token(SEMICOLON);
0305: break;
0306: default:
0307: jj_la1[4] = jj_gen;
0308: ;
0309: }
0310: int size = list.size();
0311: ImportNode[] imports = new ImportNode[size];
0312: for (int i = 0; i < size; imports[i] = (ImportNode) list
0313: .get(i++))
0314: ;
0315: {
0316: if (true)
0317: return imports;
0318: }
0319: break;
0320: case 0:
0321: jj_consume_token(0);
0322: {
0323: if (true)
0324: return null;
0325: }
0326: break;
0327: default:
0328: jj_la1[5] = jj_gen;
0329: jj_consume_token(-1);
0330: throw new ParseException();
0331: }
0332: throw new Error("Missing return statement in function");
0333: }
0334:
0335: final public void importDeclarations(ArrayList list)
0336: throws ParseException {
0337: ImportNode n;
0338: n = importDeclaration();
0339: list.add(n);
0340: label_3: while (true) {
0341: if (jj_2_3(2)) {
0342: ;
0343: } else {
0344: break label_3;
0345: }
0346: jj_consume_token(SEMICOLON);
0347: n = importDeclaration();
0348: list.add(n);
0349: }
0350: }
0351:
0352: final public ImportNode importDeclaration() throws ParseException {
0353: ImportNode n = new ImportNode();
0354: Token t;
0355: StringBuffer sb = new StringBuffer();
0356: jj_consume_token(IMPORT);
0357: t = jj_consume_token(IDENTIFIER);
0358: sb.append(t.image);
0359: label_4: while (true) {
0360: if (jj_2_4(2)) {
0361: ;
0362: } else {
0363: break label_4;
0364: }
0365: jj_consume_token(DOT);
0366: t = jj_consume_token(IDENTIFIER);
0367: sb.append(".");
0368: sb.append(t.image);
0369: }
0370: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0371: case DOT:
0372: jj_consume_token(DOT);
0373: t = jj_consume_token(STAR);
0374: sb.append(".");
0375: n.all = true;
0376: break;
0377: default:
0378: jj_la1[6] = jj_gen;
0379: ;
0380: }
0381: n.name = sb.toString();
0382: {
0383: if (true)
0384: return n;
0385: }
0386: throw new Error("Missing return statement in function");
0387: }
0388:
0389: /**
0390: * orderSpecification declaration
0391: */
0392: final public OrderNode[] setOrderings() throws ParseException {
0393: ArrayList list = new ArrayList();
0394: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0395: case MAX:
0396: case MIN:
0397: case AVG:
0398: case COUNT_STAR:
0399: case COUNT:
0400: case SUM:
0401: case THIS:
0402: case INTEGER_LITERAL:
0403: case FLOATING_POINT_LITERAL:
0404: case CHARACTER_LITERAL:
0405: case NULL:
0406: case BOOLEAN_LITERAL:
0407: case STRING_LITERAL:
0408: case IDENTIFIER:
0409: case LPAREN:
0410: case BANG:
0411: case TILDE:
0412: orderSpecifications(list);
0413: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0414: case COMMA:
0415: jj_consume_token(COMMA);
0416: break;
0417: default:
0418: jj_la1[7] = jj_gen;
0419: ;
0420: }
0421: int size = list.size();
0422: OrderNode[] orders = new OrderNode[size];
0423: for (int i = 0; i < size; orders[i] = (OrderNode) list
0424: .get(i++))
0425: ;
0426: {
0427: if (true)
0428: return orders;
0429: }
0430: break;
0431: case 0:
0432: jj_consume_token(0);
0433: {
0434: if (true)
0435: return null;
0436: }
0437: break;
0438: default:
0439: jj_la1[8] = jj_gen;
0440: jj_consume_token(-1);
0441: throw new ParseException();
0442: }
0443: throw new Error("Missing return statement in function");
0444: }
0445:
0446: final public void orderSpecifications(ArrayList list)
0447: throws ParseException {
0448: OrderNode n;
0449: n = orderSpecification();
0450: list.add(n);
0451: label_5: while (true) {
0452: if (jj_2_5(2)) {
0453: ;
0454: } else {
0455: break label_5;
0456: }
0457: jj_consume_token(COMMA);
0458: n = orderSpecification();
0459: list.add(n);
0460: }
0461: }
0462:
0463: final public OrderNode orderSpecification() throws ParseException {
0464: OrderNode n = new OrderNode();
0465: n.childList = unaryExpressionNotPlusMinus();
0466: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0467: case ASCENDING:
0468: jj_consume_token(ASCENDING);
0469: n.order = OrderNode.ORDER_ASCENDING;
0470: break;
0471: case DESCENDING:
0472: jj_consume_token(DESCENDING);
0473: n.order = OrderNode.ORDER_DESCENDING;
0474: break;
0475: default:
0476: jj_la1[9] = jj_gen;
0477: jj_consume_token(-1);
0478: throw new ParseException();
0479: }
0480: n.childList.parent = n;
0481: {
0482: if (true)
0483: return n;
0484: }
0485: throw new Error("Missing return statement in function");
0486: }
0487:
0488: /**
0489: * orderSpecification declaration
0490: */
0491: final public ResultNode setResults() throws ParseException {
0492: ResultNode rNode = null;
0493: Node current = null;
0494: boolean distinct = false;
0495: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0496: case DISTINCT:
0497: jj_consume_token(DISTINCT);
0498: distinct = true;
0499: break;
0500: default:
0501: jj_la1[10] = jj_gen;
0502: ;
0503: }
0504: current = setResultsImp(rNode);
0505: rNode = new ResultNode(current);
0506: current.parent = rNode;
0507: rNode.setDistinct(distinct);
0508: label_6: while (true) {
0509: if (jj_2_6(2)) {
0510: ;
0511: } else {
0512: break label_6;
0513: }
0514: jj_consume_token(COMMA);
0515: current.next = setResultsImp(rNode);
0516: current = current.next;
0517: }
0518: {
0519: if (true)
0520: return rNode;
0521: }
0522: throw new Error("Missing return statement in function");
0523: }
0524:
0525: final public Node setResultsImp(Node parent) throws ParseException {
0526: Node n = null;
0527: if (jj_2_7(2147483647)) {
0528: jj_consume_token(COUNT_STAR);
0529: n = new AggregateCountStarNode(parent);
0530: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0531: case AS:
0532: jj_consume_token(AS);
0533: AsClause(n);
0534: break;
0535: default:
0536: jj_la1[11] = jj_gen;
0537: ;
0538: }
0539: {
0540: if (true)
0541: return n;
0542: }
0543: } else if (jj_2_8(2147483647)) {
0544: jj_consume_token(COUNT);
0545: n = aggregateNode(AggregateNode.TYPE_COUNT, parent);
0546: {
0547: if (true)
0548: return n;
0549: }
0550: } else if (jj_2_9(2147483647)) {
0551: jj_consume_token(AVG);
0552: n = aggregateNode(AggregateNode.TYPE_AVG, parent);
0553: {
0554: if (true)
0555: return n;
0556: }
0557: } else if (jj_2_10(2147483647)) {
0558: jj_consume_token(SUM);
0559: n = aggregateNode(AggregateNode.TYPE_SUM, parent);
0560: {
0561: if (true)
0562: return n;
0563: }
0564: } else if (jj_2_11(2147483647)) {
0565: jj_consume_token(MIN);
0566: n = aggregateNode(AggregateNode.TYPE_MIN, parent);
0567: {
0568: if (true)
0569: return n;
0570: }
0571: } else if (jj_2_12(2147483647)) {
0572: jj_consume_token(MAX);
0573: n = aggregateNode(AggregateNode.TYPE_MAX, parent);
0574: {
0575: if (true)
0576: return n;
0577: }
0578: } else {
0579: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0580: case MAX:
0581: case MIN:
0582: case AVG:
0583: case COUNT_STAR:
0584: case COUNT:
0585: case SUM:
0586: case THIS:
0587: case INTEGER_LITERAL:
0588: case FLOATING_POINT_LITERAL:
0589: case CHARACTER_LITERAL:
0590: case NULL:
0591: case BOOLEAN_LITERAL:
0592: case STRING_LITERAL:
0593: case IDENTIFIER:
0594: case LPAREN:
0595: case BANG:
0596: case TILDE:
0597: case PLUS:
0598: case MINUS:
0599: n = unExpImp();
0600: n.parent = parent;
0601: {
0602: if (true)
0603: return n;
0604: }
0605: break;
0606: default:
0607: jj_la1[12] = jj_gen;
0608: jj_consume_token(-1);
0609: throw new ParseException();
0610: }
0611: }
0612: throw new Error("Missing return statement in function");
0613: }
0614:
0615: final public Node aggregateNode(int type, Node parent)
0616: throws ParseException {
0617: AggregateNode an = null;
0618: Node n = null;
0619: n = unExpImp();
0620: an = new AggregateNode(n, type);
0621: an.parent = parent;
0622: {
0623: if (true)
0624: return an;
0625: }
0626: throw new Error("Missing return statement in function");
0627: }
0628:
0629: final public Node unExpImp() throws ParseException {
0630: Node n = null;
0631: n = unaryExpression();
0632: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0633: case AS:
0634: jj_consume_token(AS);
0635: AsClause(n);
0636: break;
0637: default:
0638: jj_la1[13] = jj_gen;
0639: ;
0640: }
0641: {
0642: if (true)
0643: return n;
0644: }
0645: throw new Error("Missing return statement in function");
0646: }
0647:
0648: final public void AsClause(Node n) throws ParseException {
0649: Token t = null;
0650: t = jj_consume_token(IDENTIFIER);
0651: n.asValue = t.image;
0652: }
0653:
0654: /**
0655: * (LOOKAHEAD(<COMMA>) <COMMA> current.next = setGroupingImp(gNode, gNode) {current = current.next; })*
0656: */
0657: final public GroupingNode setGrouping() throws ParseException {
0658: Node current = null;
0659: GroupingNode gNode = null;
0660: Node having = null;
0661: current = setGroupingImp(gNode, gNode);
0662: gNode = new GroupingNode();
0663: gNode.childList = current;
0664: current.parent = gNode;
0665: label_7: while (true) {
0666: if (jj_2_13(2147483647)) {
0667: ;
0668: } else {
0669: break label_7;
0670: }
0671: jj_consume_token(COMMA);
0672: current.next = setGroupingImp(gNode, gNode);
0673: current = current.next;
0674: }
0675: if (jj_2_14(2147483647)) {
0676: jj_consume_token(HAVING);
0677: having = orExpression();
0678: gNode.havingNode = having;
0679: having.parent = gNode;
0680: } else {
0681: ;
0682: }
0683: {
0684: if (true)
0685: return gNode;
0686: }
0687: throw new Error("Missing return statement in function");
0688: }
0689:
0690: /**
0691: *[LOOKAHEAD(<HAVING>) <HAVING> having = unaryExpression(){gNode.havingNode = having; having.parent = gNode;}]
0692: */
0693: final public Node setGroupingImp(Node parent, GroupingNode gNode)
0694: throws ParseException {
0695: Node n = null;
0696: Node having = null;
0697: n = unaryExpression();
0698: n.parent = parent;
0699: {
0700: if (true)
0701: return n;
0702: }
0703: throw new Error("Missing return statement in function");
0704: }
0705:
0706: final public Node nameOrThis() throws ParseException {
0707: Node n = null;
0708: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0709: case IDENTIFIER:
0710: n = name();
0711: {
0712: if (true)
0713: return n;
0714: }
0715: break;
0716: case THIS:
0717: jj_consume_token(THIS);
0718: {
0719: if (true)
0720: return new ReservedFieldNode(
0721: ReservedFieldNode.TYPE_THIS, "this");
0722: }
0723: break;
0724: default:
0725: jj_la1[14] = jj_gen;
0726: jj_consume_token(-1);
0727: throw new ParseException();
0728: }
0729: throw new Error("Missing return statement in function");
0730: }
0731:
0732: /**
0733: * Filter Expression
0734: */
0735: final public Node filterExpression() throws ParseException {
0736: Node n;
0737: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0738: case MAX:
0739: case MIN:
0740: case AVG:
0741: case COUNT_STAR:
0742: case COUNT:
0743: case SUM:
0744: case THIS:
0745: case INTEGER_LITERAL:
0746: case FLOATING_POINT_LITERAL:
0747: case CHARACTER_LITERAL:
0748: case NULL:
0749: case BOOLEAN_LITERAL:
0750: case STRING_LITERAL:
0751: case IDENTIFIER:
0752: case LPAREN:
0753: case BANG:
0754: case TILDE:
0755: case PLUS:
0756: case MINUS:
0757: n = orExpression();
0758: jj_consume_token(0);
0759: {
0760: if (true)
0761: return n;
0762: }
0763: break;
0764: case 0:
0765: jj_consume_token(0);
0766: {
0767: if (true)
0768: return null;
0769: }
0770: break;
0771: default:
0772: jj_la1[15] = jj_gen;
0773: jj_consume_token(-1);
0774: throw new ParseException();
0775: }
0776: throw new Error("Missing return statement in function");
0777: }
0778:
0779: final public Node orExpression() throws ParseException {
0780: OrNode node = new OrNode();
0781: Node n = null;
0782: Node pos = null;
0783: n = andExpression();
0784: pos = node.childList = n;
0785: label_8: while (true) {
0786: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0787: case SC_OR:
0788: case BIT_OR:
0789: ;
0790: break;
0791: default:
0792: jj_la1[16] = jj_gen;
0793: break label_8;
0794: }
0795: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0796: case SC_OR:
0797: jj_consume_token(SC_OR);
0798: break;
0799: case BIT_OR:
0800: jj_consume_token(BIT_OR);
0801: break;
0802: default:
0803: jj_la1[17] = jj_gen;
0804: jj_consume_token(-1);
0805: throw new ParseException();
0806: }
0807: n = andExpression();
0808: pos = pos.next = n;
0809: }
0810: if (pos == node.childList) {
0811: if (true)
0812: return n;
0813: }
0814: node.setParentOnChildren();
0815: {
0816: if (true)
0817: return node;
0818: }
0819: throw new Error("Missing return statement in function");
0820: }
0821:
0822: final public Node andExpression() throws ParseException {
0823: AndNode node = new AndNode();
0824: Node n = null;
0825: Node pos = null;
0826: if (jj_2_15(2147483647)) {
0827: n = equalityExpression();
0828: } else {
0829: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0830: case MAX:
0831: case MIN:
0832: case AVG:
0833: case COUNT_STAR:
0834: case COUNT:
0835: case SUM:
0836: case THIS:
0837: case INTEGER_LITERAL:
0838: case FLOATING_POINT_LITERAL:
0839: case CHARACTER_LITERAL:
0840: case NULL:
0841: case BOOLEAN_LITERAL:
0842: case STRING_LITERAL:
0843: case IDENTIFIER:
0844: case LPAREN:
0845: case BANG:
0846: case TILDE:
0847: case PLUS:
0848: case MINUS:
0849: n = inequalityExpression();
0850: break;
0851: default:
0852: jj_la1[18] = jj_gen;
0853: jj_consume_token(-1);
0854: throw new ParseException();
0855: }
0856: }
0857: pos = node.childList = n;
0858: label_9: while (true) {
0859: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0860: case SC_AND:
0861: case BIT_AND:
0862: ;
0863: break;
0864: default:
0865: jj_la1[19] = jj_gen;
0866: break label_9;
0867: }
0868: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0869: case SC_AND:
0870: jj_consume_token(SC_AND);
0871: break;
0872: case BIT_AND:
0873: jj_consume_token(BIT_AND);
0874: break;
0875: default:
0876: jj_la1[20] = jj_gen;
0877: jj_consume_token(-1);
0878: throw new ParseException();
0879: }
0880: if (jj_2_16(2147483647)) {
0881: n = equalityExpression();
0882: } else {
0883: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0884: case MAX:
0885: case MIN:
0886: case AVG:
0887: case COUNT_STAR:
0888: case COUNT:
0889: case SUM:
0890: case THIS:
0891: case INTEGER_LITERAL:
0892: case FLOATING_POINT_LITERAL:
0893: case CHARACTER_LITERAL:
0894: case NULL:
0895: case BOOLEAN_LITERAL:
0896: case STRING_LITERAL:
0897: case IDENTIFIER:
0898: case LPAREN:
0899: case BANG:
0900: case TILDE:
0901: case PLUS:
0902: case MINUS:
0903: n = inequalityExpression();
0904: break;
0905: default:
0906: jj_la1[21] = jj_gen;
0907: jj_consume_token(-1);
0908: throw new ParseException();
0909: }
0910: }
0911: pos = pos.next = n;
0912: }
0913: if (pos == node.childList) {
0914: if (true)
0915: return n;
0916: }
0917: node.setParentOnChildren();
0918: {
0919: if (true)
0920: return node;
0921: }
0922: throw new Error("Missing return statement in function");
0923: }
0924:
0925: final public Node equalityExpression() throws ParseException {
0926: Node n1;
0927: Node n2;
0928: n1 = relationalExpression();
0929: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0930: case EQ:
0931: jj_consume_token(EQ);
0932: n2 = relationalExpression();
0933: n1 = new EqualNode(n1, n2);
0934: break;
0935: default:
0936: jj_la1[22] = jj_gen;
0937: ;
0938: }
0939: //System.out.println("returning equality = "+n1);
0940: {
0941: if (true)
0942: return n1;
0943: }
0944: throw new Error("Missing return statement in function");
0945: }
0946:
0947: final public Node inequalityExpression() throws ParseException {
0948: Node n1;
0949: Node n2;
0950: n1 = relationalExpression();
0951: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0952: case NE:
0953: jj_consume_token(NE);
0954: n2 = relationalExpression();
0955: n1 = new NotEqualNode(n1, n2);
0956: break;
0957: default:
0958: jj_la1[23] = jj_gen;
0959: ;
0960: }
0961: //System.out.println("returning inequality = "+n1);
0962: {
0963: if (true)
0964: return n1;
0965: }
0966: throw new Error("Missing return statement in function");
0967: }
0968:
0969: final public Node relationalExpression() throws ParseException {
0970: Node n1;
0971: Node n2;
0972: int op = 0;
0973: n1 = additiveExpression();
0974: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0975: case GT:
0976: case LT:
0977: case LE:
0978: case GE:
0979: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0980: case LT:
0981: jj_consume_token(LT);
0982: op = CompareOpNode.LT;
0983: break;
0984: case GT:
0985: jj_consume_token(GT);
0986: op = CompareOpNode.GT;
0987: break;
0988: case LE:
0989: jj_consume_token(LE);
0990: op = CompareOpNode.LE;
0991: break;
0992: case GE:
0993: jj_consume_token(GE);
0994: op = CompareOpNode.GE;
0995: break;
0996: default:
0997: jj_la1[24] = jj_gen;
0998: jj_consume_token(-1);
0999: throw new ParseException();
1000: }
1001: n2 = additiveExpression();
1002: n1 = new CompareOpNode(n1, n2, op);
1003: break;
1004: default:
1005: jj_la1[25] = jj_gen;
1006: ;
1007: }
1008: //System.out.println("returning relational = "+n1);
1009: {
1010: if (true)
1011: return n1;
1012: }
1013: throw new Error("Missing return statement in function");
1014: }
1015:
1016: final public Node additiveExpression() throws ParseException {
1017: AddNode node = new AddNode();
1018: Node n = null;
1019: Node pos = null;
1020: IntArray ops = new IntArray();
1021: n = multiplicativeExpression();
1022: pos = node.childList = n;
1023: label_10: while (true) {
1024: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1025: case PLUS:
1026: case MINUS:
1027: ;
1028: break;
1029: default:
1030: jj_la1[26] = jj_gen;
1031: break label_10;
1032: }
1033: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1034: case PLUS:
1035: jj_consume_token(PLUS);
1036: ops.add(node.OP_PLUS);
1037: break;
1038: case MINUS:
1039: jj_consume_token(MINUS);
1040: ops.add(node.OP_MINUS);
1041: break;
1042: default:
1043: jj_la1[27] = jj_gen;
1044: jj_consume_token(-1);
1045: throw new ParseException();
1046: }
1047: n = multiplicativeExpression();
1048: pos = pos.next = n;
1049: }
1050: if (pos == node.childList) {
1051: if (true)
1052: return n;
1053: }
1054: node.setParentOnChildren();
1055: node.ops = ops.toArray();
1056: {
1057: if (true)
1058: return node;
1059: }
1060: throw new Error("Missing return statement in function");
1061: }
1062:
1063: final public Node multiplicativeExpression() throws ParseException {
1064: MultiplyNode node = new MultiplyNode();
1065: Node n = null;
1066: Node pos = null;
1067: IntArray ops = new IntArray();
1068: n = unaryExpression();
1069: pos = node.childList = n;
1070: label_11: while (true) {
1071: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1072: case STAR:
1073: case SLASH:
1074: ;
1075: break;
1076: default:
1077: jj_la1[28] = jj_gen;
1078: break label_11;
1079: }
1080: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1081: case STAR:
1082: jj_consume_token(STAR);
1083: ops.add(node.OP_TIMES);
1084: break;
1085: case SLASH:
1086: jj_consume_token(SLASH);
1087: ops.add(node.OP_DIVIDE);
1088: break;
1089: default:
1090: jj_la1[29] = jj_gen;
1091: jj_consume_token(-1);
1092: throw new ParseException();
1093: }
1094: n = unaryExpression();
1095: pos = pos.next = n;
1096: }
1097: if (pos == node.childList) {
1098: if (true)
1099: return n;
1100: }
1101: node.setParentOnChildren();
1102: node.ops = ops.toArray();
1103: {
1104: if (true)
1105: return node;
1106: }
1107: throw new Error("Missing return statement in function");
1108: }
1109:
1110: final public Node unaryExpression() throws ParseException {
1111: Node n;
1112: int op;
1113: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1114: case PLUS:
1115: case MINUS:
1116: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1117: case PLUS:
1118: jj_consume_token(PLUS);
1119: op = UnaryOpNode.OP_PLUS;
1120: break;
1121: case MINUS:
1122: jj_consume_token(MINUS);
1123: op = UnaryOpNode.OP_MINUS;
1124: break;
1125: default:
1126: jj_la1[30] = jj_gen;
1127: jj_consume_token(-1);
1128: throw new ParseException();
1129: }
1130: n = unaryExpression();
1131: {
1132: if (true)
1133: return new UnaryOpNode(n, op);
1134: }
1135: break;
1136: case MAX:
1137: case MIN:
1138: case AVG:
1139: case COUNT_STAR:
1140: case COUNT:
1141: case SUM:
1142: case THIS:
1143: case INTEGER_LITERAL:
1144: case FLOATING_POINT_LITERAL:
1145: case CHARACTER_LITERAL:
1146: case NULL:
1147: case BOOLEAN_LITERAL:
1148: case STRING_LITERAL:
1149: case IDENTIFIER:
1150: case LPAREN:
1151: case BANG:
1152: case TILDE:
1153: n = unaryExpressionNotPlusMinus();
1154: //System.out.println("returning unaryExpression = "+n);
1155: {
1156: if (true)
1157: return n;
1158: }
1159: break;
1160: default:
1161: jj_la1[31] = jj_gen;
1162: jj_consume_token(-1);
1163: throw new ParseException();
1164: }
1165: throw new Error("Missing return statement in function");
1166: }
1167:
1168: final public Node unaryExpressionNotPlusMinus()
1169: throws ParseException {
1170: Node n;
1171: int op;
1172: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1173: case BANG:
1174: case TILDE:
1175: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1176: case TILDE:
1177: jj_consume_token(TILDE);
1178: op = UnaryOpNode.OP_TILDE;
1179: break;
1180: case BANG:
1181: jj_consume_token(BANG);
1182: op = UnaryOpNode.OP_BANG;
1183: break;
1184: default:
1185: jj_la1[32] = jj_gen;
1186: jj_consume_token(-1);
1187: throw new ParseException();
1188: }
1189: n = unaryExpression();
1190: {
1191: if (true)
1192: return new UnaryOpNode(n, op);
1193: }
1194: break;
1195: default:
1196: jj_la1[33] = jj_gen;
1197: if (jj_2_17(2147483647)) {
1198: n = castExpression();
1199: {
1200: if (true)
1201: return n;
1202: }
1203: } else {
1204: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1205: case MAX:
1206: case MIN:
1207: case AVG:
1208: case COUNT_STAR:
1209: case COUNT:
1210: case SUM:
1211: case THIS:
1212: case INTEGER_LITERAL:
1213: case FLOATING_POINT_LITERAL:
1214: case CHARACTER_LITERAL:
1215: case NULL:
1216: case BOOLEAN_LITERAL:
1217: case STRING_LITERAL:
1218: case IDENTIFIER:
1219: case LPAREN:
1220: n = primaryExpression();
1221: //System.out.println("returning unaryExpressionNOtPlusMinus = "+n);
1222: {
1223: if (true)
1224: return n;
1225: }
1226: break;
1227: default:
1228: jj_la1[34] = jj_gen;
1229: jj_consume_token(-1);
1230: throw new ParseException();
1231: }
1232: }
1233: }
1234: throw new Error("Missing return statement in function");
1235: }
1236:
1237: // This production is to determine lookahead.
1238: final public void castLookahead() throws ParseException {
1239: if (jj_2_18(2147483647)) {
1240: jj_consume_token(LPAREN);
1241: type();
1242: jj_consume_token(LBRACKET);
1243: jj_consume_token(RBRACKET);
1244: } else {
1245: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1246: case LPAREN:
1247: jj_consume_token(LPAREN);
1248: type();
1249: jj_consume_token(RPAREN);
1250: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1251: case TILDE:
1252: jj_consume_token(TILDE);
1253: break;
1254: case BANG:
1255: jj_consume_token(BANG);
1256: break;
1257: case LPAREN:
1258: jj_consume_token(LPAREN);
1259: break;
1260: case IDENTIFIER:
1261: jj_consume_token(IDENTIFIER);
1262: break;
1263: case THIS:
1264: jj_consume_token(THIS);
1265: break;
1266: case INTEGER_LITERAL:
1267: case FLOATING_POINT_LITERAL:
1268: case CHARACTER_LITERAL:
1269: case NULL:
1270: case BOOLEAN_LITERAL:
1271: case STRING_LITERAL:
1272: literal();
1273: break;
1274: default:
1275: jj_la1[35] = jj_gen;
1276: jj_consume_token(-1);
1277: throw new ParseException();
1278: }
1279: break;
1280: default:
1281: jj_la1[36] = jj_gen;
1282: jj_consume_token(-1);
1283: throw new ParseException();
1284: }
1285: }
1286: }
1287:
1288: final public Node castExpression() throws ParseException {
1289: Object tp;
1290: int brackets = 0;
1291: Node n;
1292: jj_consume_token(LPAREN);
1293: tp = type();
1294: label_12: while (true) {
1295: if (jj_2_19(2)) {
1296: ;
1297: } else {
1298: break label_12;
1299: }
1300: jj_consume_token(LBRACKET);
1301: brackets++;
1302: jj_consume_token(RBRACKET);
1303: }
1304: jj_consume_token(RPAREN);
1305: n = unaryExpression();
1306: {
1307: if (true)
1308: return new CastNode(n, brackets, tp);
1309: }
1310: throw new Error("Missing return statement in function");
1311: }
1312:
1313: final public Node primaryExpression() throws ParseException {
1314: PrimaryExprNode node = new PrimaryExprNode();
1315: Node n = null;
1316: Node pos = null;
1317: n = primaryPrefix();
1318: pos = node.childList = n;
1319: label_13: while (true) {
1320: if (jj_2_20(3)) {
1321: ;
1322: } else {
1323: break label_13;
1324: }
1325: n = primarySuffix();
1326: pos = pos.next = n;
1327: }
1328: /*if(pos == node.childList && ! (node.childList instanceof MethodNode)){
1329: return n;
1330: }
1331: node.setParentOnChildren();
1332: return resolveMethod(node);
1333: */
1334:
1335: if (pos == node.childList
1336: && !(node.childList instanceof MethodNode)) {
1337: {
1338: if (true)
1339: return node.childList;
1340: }
1341: } else {
1342: Node tmp = node;
1343: tmp.setParentOnChildren();
1344: resolveMethod(tmp);
1345:
1346: if (tmp.childList.next == null) {
1347: tmp = tmp.childList;
1348: }
1349:
1350: if (tmp != null
1351: && tmp.childList instanceof ReservedFieldNode) {
1352: Node tmp2 = tmp.childList;
1353: tmp2.childList = tmp2.next;
1354:
1355: if (tmp2.childList != null) {
1356: tmp2.next = tmp2.childList.next;
1357: tmp2.childList.next = null;
1358: } else {
1359: tmp2.next = null;
1360: }
1361: tmp2.setParentOnChildren();
1362: }
1363: tmp.setParentOnChildren();
1364: if (tmp instanceof PrimaryExprNode
1365: && tmp.childList.next == null) {
1366: tmp = tmp.childList;
1367: }
1368: tmp.parent = null;
1369: {
1370: if (true)
1371: return tmp;
1372: }
1373: }
1374:
1375: //return node;
1376:
1377: throw new Error("Missing return statement in function");
1378: }
1379:
1380: final public Node primaryPrefix() throws ParseException {
1381: Node n = null;
1382: Token t;
1383: Node tmp;
1384: if (jj_2_21(2147483647)) {
1385: jj_consume_token(COUNT_STAR);
1386: {
1387: if (true)
1388: return new AggregateCountStarNode();
1389: }
1390: } else if (jj_2_22(2147483647)) {
1391: jj_consume_token(COUNT);
1392: tmp = unaryExpression();
1393: n = new AggregateNode(tmp, AggregateNode.TYPE_COUNT);
1394: {
1395: if (true)
1396: return n;
1397: }
1398: } else if (jj_2_23(2147483647)) {
1399: jj_consume_token(AVG);
1400: tmp = unaryExpression();
1401: n = new AggregateNode(tmp, AggregateNode.TYPE_AVG);
1402: {
1403: if (true)
1404: return n;
1405: }
1406: } else if (jj_2_24(2147483647)) {
1407: jj_consume_token(SUM);
1408: tmp = unaryExpression();
1409: n = new AggregateNode(tmp, AggregateNode.TYPE_SUM);
1410: {
1411: if (true)
1412: return n;
1413: }
1414: } else if (jj_2_25(2147483647)) {
1415: jj_consume_token(MIN);
1416: tmp = unaryExpression();
1417: n = new AggregateNode(tmp, AggregateNode.TYPE_MIN);
1418: {
1419: if (true)
1420: return n;
1421: }
1422: } else if (jj_2_26(2147483647)) {
1423: jj_consume_token(MAX);
1424: tmp = unaryExpression();
1425: n = new AggregateNode(tmp, AggregateNode.TYPE_MAX);
1426: {
1427: if (true)
1428: return n;
1429: }
1430: } else {
1431: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1432: case INTEGER_LITERAL:
1433: case FLOATING_POINT_LITERAL:
1434: case CHARACTER_LITERAL:
1435: case NULL:
1436: case BOOLEAN_LITERAL:
1437: case STRING_LITERAL:
1438: n = literal();
1439: break;
1440: case IDENTIFIER:
1441: n = name();
1442: break;
1443: case THIS:
1444: jj_consume_token(THIS);
1445: n = new ReservedFieldNode(ReservedFieldNode.TYPE_THIS,
1446: "this");
1447: break;
1448: case LPAREN:
1449: jj_consume_token(LPAREN);
1450: n = orExpression();
1451: jj_consume_token(RPAREN);
1452: break;
1453: default:
1454: jj_la1[37] = jj_gen;
1455: jj_consume_token(-1);
1456: throw new ParseException();
1457: }
1458: }
1459: //System.out.println("returning primaryPrefix = "+n);
1460: {
1461: if (true)
1462: return n;
1463: }
1464: throw new Error("Missing return statement in function");
1465: }
1466:
1467: final public Node primarySuffix() throws ParseException {
1468: Token t;
1469: Node n;
1470: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1471: case LBRACKET:
1472: jj_consume_token(LBRACKET);
1473: n = orExpression();
1474: jj_consume_token(RBRACKET);
1475: ArrayNode an = new ArrayNode();
1476: an.args = n;
1477: if (n != null)
1478: n.parent = an;
1479: {
1480: if (true)
1481: return an;
1482: }
1483: break;
1484: case DOT:
1485: jj_consume_token(DOT);
1486: n = name();
1487: {
1488: if (true)
1489: return n;
1490: }
1491: break;
1492: case LPAREN:
1493: n = arguments();
1494: MethodNode mn = new MethodNode();
1495: //mn.args = n;
1496: mn.childList = n;
1497: if (n != null) {
1498: n.next = null;
1499: n.parent = mn;
1500: }
1501: {
1502: if (true)
1503: return mn;
1504: }
1505: break;
1506: default:
1507: jj_la1[38] = jj_gen;
1508: jj_consume_token(-1);
1509: throw new ParseException();
1510: }
1511: throw new Error("Missing return statement in function");
1512: }
1513:
1514: final public Node arguments() throws ParseException {
1515: Node n = null;
1516: jj_consume_token(LPAREN);
1517: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1518: case MAX:
1519: case MIN:
1520: case AVG:
1521: case COUNT_STAR:
1522: case COUNT:
1523: case SUM:
1524: case THIS:
1525: case INTEGER_LITERAL:
1526: case FLOATING_POINT_LITERAL:
1527: case CHARACTER_LITERAL:
1528: case NULL:
1529: case BOOLEAN_LITERAL:
1530: case STRING_LITERAL:
1531: case IDENTIFIER:
1532: case LPAREN:
1533: case BANG:
1534: case TILDE:
1535: case PLUS:
1536: case MINUS:
1537: n = argumentList();
1538: break;
1539: default:
1540: jj_la1[39] = jj_gen;
1541: ;
1542: }
1543: jj_consume_token(RPAREN);
1544: {
1545: if (true)
1546: return n;
1547: }
1548: throw new Error("Missing return statement in function");
1549: }
1550:
1551: final public Node argumentList() throws ParseException {
1552: ArgNode node = new ArgNode();
1553: Node n = null;
1554: Node pos = null;
1555: n = orExpression();
1556: pos = node.childList = n;
1557: label_14: while (true) {
1558: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1559: case COMMA:
1560: ;
1561: break;
1562: default:
1563: jj_la1[40] = jj_gen;
1564: break label_14;
1565: }
1566: jj_consume_token(COMMA);
1567: n = orExpression();
1568: }
1569: pos = pos.next = n;
1570: if (pos == node.childList) {
1571: if (true)
1572: return n;
1573: }
1574: node.setParentOnChildren();
1575: {
1576: if (true)
1577: return node;
1578: }
1579: throw new Error("Missing return statement in function");
1580: }
1581:
1582: /**
1583: * Definition of types. Primitives and Names (e.g. String).
1584: */
1585: final public Object type() throws ParseException {
1586: CharBuf s = null;
1587: Token t = null;
1588: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1589: case INT:
1590: jj_consume_token(INT);
1591: {
1592: if (true)
1593: return Integer.TYPE;
1594: }
1595: break;
1596: case BYTE:
1597: jj_consume_token(BYTE);
1598: {
1599: if (true)
1600: return Byte.TYPE;
1601: }
1602: break;
1603: case SHORT:
1604: jj_consume_token(SHORT);
1605: {
1606: if (true)
1607: return Short.TYPE;
1608: }
1609: break;
1610: case LONG:
1611: jj_consume_token(LONG);
1612: {
1613: if (true)
1614: return Long.TYPE;
1615: }
1616: break;
1617: case CHAR:
1618: jj_consume_token(CHAR);
1619: {
1620: if (true)
1621: return Character.TYPE;
1622: }
1623: break;
1624: case FLOAT:
1625: jj_consume_token(FLOAT);
1626: {
1627: if (true)
1628: return Float.TYPE;
1629: }
1630: break;
1631: case DOUBLE:
1632: jj_consume_token(DOUBLE);
1633: {
1634: if (true)
1635: return Double.TYPE;
1636: }
1637: break;
1638: case BOOLEAN:
1639: jj_consume_token(BOOLEAN);
1640: {
1641: if (true)
1642: return Boolean.TYPE;
1643: }
1644: break;
1645: case IDENTIFIER:
1646: s = new CharBuf();
1647: t = jj_consume_token(IDENTIFIER);
1648: s.append(t.image);
1649: label_15: while (true) {
1650: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1651: case DOT:
1652: ;
1653: break;
1654: default:
1655: jj_la1[41] = jj_gen;
1656: break label_15;
1657: }
1658: jj_consume_token(DOT);
1659: s.append(".");
1660: t = jj_consume_token(IDENTIFIER);
1661: s.append(t.image);
1662: }
1663: {
1664: if (true)
1665: return s.toString();
1666: }
1667: break;
1668: default:
1669: jj_la1[42] = jj_gen;
1670: jj_consume_token(-1);
1671: throw new ParseException();
1672: }
1673: throw new Error("Missing return statement in function");
1674: }
1675:
1676: final public Node name() throws ParseException {
1677: ArrayList list = new ArrayList();
1678: Token t = null;
1679: t = jj_consume_token(IDENTIFIER);
1680: list.add(t.image);
1681: label_16: while (true) {
1682: if (jj_2_27(2)) {
1683: ;
1684: } else {
1685: break label_16;
1686: }
1687: jj_consume_token(DOT);
1688: t = jj_consume_token(IDENTIFIER);
1689: list.add(t.image);
1690: }
1691: FieldNavNode parent = null;
1692: Node root = null;
1693: for (int i = 0; i < list.size() - 1; i++) {
1694: FieldNavNode node = new FieldNavNode();
1695: node.parent = parent;
1696: node.lexeme = (String) list.get(i);
1697: if (parent != null) {
1698: parent.childList = node;
1699: } else {
1700: root = node;
1701: }
1702: parent = node;
1703: }
1704:
1705: FieldNode node = new FieldNode(parent, t.image);
1706: // node.parent = parent;
1707: // node.lexeme = t.image;
1708: if (parent != null) {
1709: parent.childList = node;
1710: } else {
1711: root = node;
1712: }
1713: //System.out.println("returning name = "+root);
1714: {
1715: if (true)
1716: return root;
1717: }
1718: throw new Error("Missing return statement in function");
1719: }
1720:
1721: final public LiteralNode literal() throws ParseException {
1722: Token t = null;
1723: LiteralNode literal = new LiteralNode(null,
1724: LiteralNode.TYPE_OTHER, null);
1725: StringBuffer buffer;
1726: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1727: case INTEGER_LITERAL:
1728: t = jj_consume_token(INTEGER_LITERAL);
1729: literal.type = LiteralNode.TYPE_LONG;
1730: break;
1731: case FLOATING_POINT_LITERAL:
1732: t = jj_consume_token(FLOATING_POINT_LITERAL);
1733: literal.type = LiteralNode.TYPE_DOUBLE;
1734: break;
1735: case BOOLEAN_LITERAL:
1736: t = jj_consume_token(BOOLEAN_LITERAL);
1737: literal.type = LiteralNode.TYPE_BOOLEAN;
1738: break;
1739: case NULL:
1740: t = jj_consume_token(NULL);
1741: literal.type = LiteralNode.TYPE_NULL;
1742: break;
1743: case STRING_LITERAL:
1744: t = jj_consume_token(STRING_LITERAL);
1745: literal.type = LiteralNode.TYPE_STRING;
1746: buffer = new StringBuffer(t.image);
1747: buffer.deleteCharAt(0);
1748: buffer.deleteCharAt(buffer.length() - 1);
1749: literal.value = buffer.toString();
1750: {
1751: if (true)
1752: return literal;
1753: }
1754: break;
1755: case CHARACTER_LITERAL:
1756: t = jj_consume_token(CHARACTER_LITERAL);
1757: literal.type = LiteralNode.TYPE_STRING;
1758: buffer = new StringBuffer(t.image);
1759: buffer.deleteCharAt(0);
1760: buffer.deleteCharAt(buffer.length() - 1);
1761: literal.value = buffer.toString();
1762: {
1763: if (true)
1764: return literal;
1765: }
1766: break;
1767: default:
1768: jj_la1[43] = jj_gen;
1769: jj_consume_token(-1);
1770: throw new ParseException();
1771: }
1772: literal.value = t.image;
1773: {
1774: if (true)
1775: return literal;
1776: }
1777: throw new Error("Missing return statement in function");
1778: }
1779:
1780: final private boolean jj_2_1(int xla) {
1781: jj_la = xla;
1782: jj_lastpos = jj_scanpos = token;
1783: try {
1784: return !jj_3_1();
1785: } catch (LookaheadSuccess ls) {
1786: return true;
1787: } finally {
1788: jj_save(0, xla);
1789: }
1790: }
1791:
1792: final private boolean jj_2_2(int xla) {
1793: jj_la = xla;
1794: jj_lastpos = jj_scanpos = token;
1795: try {
1796: return !jj_3_2();
1797: } catch (LookaheadSuccess ls) {
1798: return true;
1799: } finally {
1800: jj_save(1, xla);
1801: }
1802: }
1803:
1804: final private boolean jj_2_3(int xla) {
1805: jj_la = xla;
1806: jj_lastpos = jj_scanpos = token;
1807: try {
1808: return !jj_3_3();
1809: } catch (LookaheadSuccess ls) {
1810: return true;
1811: } finally {
1812: jj_save(2, xla);
1813: }
1814: }
1815:
1816: final private boolean jj_2_4(int xla) {
1817: jj_la = xla;
1818: jj_lastpos = jj_scanpos = token;
1819: try {
1820: return !jj_3_4();
1821: } catch (LookaheadSuccess ls) {
1822: return true;
1823: } finally {
1824: jj_save(3, xla);
1825: }
1826: }
1827:
1828: final private boolean jj_2_5(int xla) {
1829: jj_la = xla;
1830: jj_lastpos = jj_scanpos = token;
1831: try {
1832: return !jj_3_5();
1833: } catch (LookaheadSuccess ls) {
1834: return true;
1835: } finally {
1836: jj_save(4, xla);
1837: }
1838: }
1839:
1840: final private boolean jj_2_6(int xla) {
1841: jj_la = xla;
1842: jj_lastpos = jj_scanpos = token;
1843: try {
1844: return !jj_3_6();
1845: } catch (LookaheadSuccess ls) {
1846: return true;
1847: } finally {
1848: jj_save(5, xla);
1849: }
1850: }
1851:
1852: final private boolean jj_2_7(int xla) {
1853: jj_la = xla;
1854: jj_lastpos = jj_scanpos = token;
1855: try {
1856: return !jj_3_7();
1857: } catch (LookaheadSuccess ls) {
1858: return true;
1859: } finally {
1860: jj_save(6, xla);
1861: }
1862: }
1863:
1864: final private boolean jj_2_8(int xla) {
1865: jj_la = xla;
1866: jj_lastpos = jj_scanpos = token;
1867: try {
1868: return !jj_3_8();
1869: } catch (LookaheadSuccess ls) {
1870: return true;
1871: } finally {
1872: jj_save(7, xla);
1873: }
1874: }
1875:
1876: final private boolean jj_2_9(int xla) {
1877: jj_la = xla;
1878: jj_lastpos = jj_scanpos = token;
1879: try {
1880: return !jj_3_9();
1881: } catch (LookaheadSuccess ls) {
1882: return true;
1883: } finally {
1884: jj_save(8, xla);
1885: }
1886: }
1887:
1888: final private boolean jj_2_10(int xla) {
1889: jj_la = xla;
1890: jj_lastpos = jj_scanpos = token;
1891: try {
1892: return !jj_3_10();
1893: } catch (LookaheadSuccess ls) {
1894: return true;
1895: } finally {
1896: jj_save(9, xla);
1897: }
1898: }
1899:
1900: final private boolean jj_2_11(int xla) {
1901: jj_la = xla;
1902: jj_lastpos = jj_scanpos = token;
1903: try {
1904: return !jj_3_11();
1905: } catch (LookaheadSuccess ls) {
1906: return true;
1907: } finally {
1908: jj_save(10, xla);
1909: }
1910: }
1911:
1912: final private boolean jj_2_12(int xla) {
1913: jj_la = xla;
1914: jj_lastpos = jj_scanpos = token;
1915: try {
1916: return !jj_3_12();
1917: } catch (LookaheadSuccess ls) {
1918: return true;
1919: } finally {
1920: jj_save(11, xla);
1921: }
1922: }
1923:
1924: final private boolean jj_2_13(int xla) {
1925: jj_la = xla;
1926: jj_lastpos = jj_scanpos = token;
1927: try {
1928: return !jj_3_13();
1929: } catch (LookaheadSuccess ls) {
1930: return true;
1931: } finally {
1932: jj_save(12, xla);
1933: }
1934: }
1935:
1936: final private boolean jj_2_14(int xla) {
1937: jj_la = xla;
1938: jj_lastpos = jj_scanpos = token;
1939: try {
1940: return !jj_3_14();
1941: } catch (LookaheadSuccess ls) {
1942: return true;
1943: } finally {
1944: jj_save(13, xla);
1945: }
1946: }
1947:
1948: final private boolean jj_2_15(int xla) {
1949: jj_la = xla;
1950: jj_lastpos = jj_scanpos = token;
1951: try {
1952: return !jj_3_15();
1953: } catch (LookaheadSuccess ls) {
1954: return true;
1955: } finally {
1956: jj_save(14, xla);
1957: }
1958: }
1959:
1960: final private boolean jj_2_16(int xla) {
1961: jj_la = xla;
1962: jj_lastpos = jj_scanpos = token;
1963: try {
1964: return !jj_3_16();
1965: } catch (LookaheadSuccess ls) {
1966: return true;
1967: } finally {
1968: jj_save(15, xla);
1969: }
1970: }
1971:
1972: final private boolean jj_2_17(int xla) {
1973: jj_la = xla;
1974: jj_lastpos = jj_scanpos = token;
1975: try {
1976: return !jj_3_17();
1977: } catch (LookaheadSuccess ls) {
1978: return true;
1979: } finally {
1980: jj_save(16, xla);
1981: }
1982: }
1983:
1984: final private boolean jj_2_18(int xla) {
1985: jj_la = xla;
1986: jj_lastpos = jj_scanpos = token;
1987: try {
1988: return !jj_3_18();
1989: } catch (LookaheadSuccess ls) {
1990: return true;
1991: } finally {
1992: jj_save(17, xla);
1993: }
1994: }
1995:
1996: final private boolean jj_2_19(int xla) {
1997: jj_la = xla;
1998: jj_lastpos = jj_scanpos = token;
1999: try {
2000: return !jj_3_19();
2001: } catch (LookaheadSuccess ls) {
2002: return true;
2003: } finally {
2004: jj_save(18, xla);
2005: }
2006: }
2007:
2008: final private boolean jj_2_20(int xla) {
2009: jj_la = xla;
2010: jj_lastpos = jj_scanpos = token;
2011: try {
2012: return !jj_3_20();
2013: } catch (LookaheadSuccess ls) {
2014: return true;
2015: } finally {
2016: jj_save(19, xla);
2017: }
2018: }
2019:
2020: final private boolean jj_2_21(int xla) {
2021: jj_la = xla;
2022: jj_lastpos = jj_scanpos = token;
2023: try {
2024: return !jj_3_21();
2025: } catch (LookaheadSuccess ls) {
2026: return true;
2027: } finally {
2028: jj_save(20, xla);
2029: }
2030: }
2031:
2032: final private boolean jj_2_22(int xla) {
2033: jj_la = xla;
2034: jj_lastpos = jj_scanpos = token;
2035: try {
2036: return !jj_3_22();
2037: } catch (LookaheadSuccess ls) {
2038: return true;
2039: } finally {
2040: jj_save(21, xla);
2041: }
2042: }
2043:
2044: final private boolean jj_2_23(int xla) {
2045: jj_la = xla;
2046: jj_lastpos = jj_scanpos = token;
2047: try {
2048: return !jj_3_23();
2049: } catch (LookaheadSuccess ls) {
2050: return true;
2051: } finally {
2052: jj_save(22, xla);
2053: }
2054: }
2055:
2056: final private boolean jj_2_24(int xla) {
2057: jj_la = xla;
2058: jj_lastpos = jj_scanpos = token;
2059: try {
2060: return !jj_3_24();
2061: } catch (LookaheadSuccess ls) {
2062: return true;
2063: } finally {
2064: jj_save(23, xla);
2065: }
2066: }
2067:
2068: final private boolean jj_2_25(int xla) {
2069: jj_la = xla;
2070: jj_lastpos = jj_scanpos = token;
2071: try {
2072: return !jj_3_25();
2073: } catch (LookaheadSuccess ls) {
2074: return true;
2075: } finally {
2076: jj_save(24, xla);
2077: }
2078: }
2079:
2080: final private boolean jj_2_26(int xla) {
2081: jj_la = xla;
2082: jj_lastpos = jj_scanpos = token;
2083: try {
2084: return !jj_3_26();
2085: } catch (LookaheadSuccess ls) {
2086: return true;
2087: } finally {
2088: jj_save(25, xla);
2089: }
2090: }
2091:
2092: final private boolean jj_2_27(int xla) {
2093: jj_la = xla;
2094: jj_lastpos = jj_scanpos = token;
2095: try {
2096: return !jj_3_27();
2097: } catch (LookaheadSuccess ls) {
2098: return true;
2099: } finally {
2100: jj_save(26, xla);
2101: }
2102: }
2103:
2104: final private boolean jj_3_19() {
2105: if (jj_scan_token(LBRACKET))
2106: return true;
2107: if (jj_scan_token(RBRACKET))
2108: return true;
2109: return false;
2110: }
2111:
2112: final private boolean jj_3R_68() {
2113: if (jj_3R_77())
2114: return true;
2115: Token xsp;
2116: while (true) {
2117: xsp = jj_scanpos;
2118: if (jj_3_20()) {
2119: jj_scanpos = xsp;
2120: break;
2121: }
2122: }
2123: return false;
2124: }
2125:
2126: final private boolean jj_3_2() {
2127: if (jj_scan_token(SEMICOLON))
2128: return true;
2129: if (jj_3R_18())
2130: return true;
2131: return false;
2132: }
2133:
2134: final private boolean jj_3R_75() {
2135: Token xsp;
2136: xsp = jj_scanpos;
2137: if (jj_scan_token(62)) {
2138: jj_scanpos = xsp;
2139: if (jj_scan_token(69))
2140: return true;
2141: }
2142: if (jj_3R_74())
2143: return true;
2144: return false;
2145: }
2146:
2147: final private boolean jj_3_27() {
2148: if (jj_scan_token(DOT))
2149: return true;
2150: if (jj_scan_token(IDENTIFIER))
2151: return true;
2152: return false;
2153: }
2154:
2155: final private boolean jj_3R_62() {
2156: if (jj_3R_74())
2157: return true;
2158: Token xsp;
2159: while (true) {
2160: xsp = jj_scanpos;
2161: if (jj_3R_75()) {
2162: jj_scanpos = xsp;
2163: break;
2164: }
2165: }
2166: return false;
2167: }
2168:
2169: final private boolean jj_3R_67() {
2170: if (jj_scan_token(LPAREN))
2171: return true;
2172: if (jj_3R_24())
2173: return true;
2174: Token xsp;
2175: while (true) {
2176: xsp = jj_scanpos;
2177: if (jj_3_19()) {
2178: jj_scanpos = xsp;
2179: break;
2180: }
2181: }
2182: if (jj_scan_token(RPAREN))
2183: return true;
2184: if (jj_3R_69())
2185: return true;
2186: return false;
2187: }
2188:
2189: final private boolean jj_3_18() {
2190: if (jj_scan_token(LPAREN))
2191: return true;
2192: if (jj_3R_24())
2193: return true;
2194: if (jj_scan_token(LBRACKET))
2195: return true;
2196: return false;
2197: }
2198:
2199: final private boolean jj_3R_63() {
2200: if (jj_scan_token(IDENTIFIER))
2201: return true;
2202: Token xsp;
2203: while (true) {
2204: xsp = jj_scanpos;
2205: if (jj_3_27()) {
2206: jj_scanpos = xsp;
2207: break;
2208: }
2209: }
2210: return false;
2211: }
2212:
2213: final private boolean jj_3R_37() {
2214: if (jj_scan_token(LPAREN))
2215: return true;
2216: if (jj_3R_24())
2217: return true;
2218: if (jj_scan_token(RPAREN))
2219: return true;
2220: Token xsp;
2221: xsp = jj_scanpos;
2222: if (jj_scan_token(57)) {
2223: jj_scanpos = xsp;
2224: if (jj_scan_token(56)) {
2225: jj_scanpos = xsp;
2226: if (jj_scan_token(45)) {
2227: jj_scanpos = xsp;
2228: if (jj_scan_token(42)) {
2229: jj_scanpos = xsp;
2230: if (jj_scan_token(31)) {
2231: jj_scanpos = xsp;
2232: if (jj_3R_60())
2233: return true;
2234: }
2235: }
2236: }
2237: }
2238: }
2239: return false;
2240: }
2241:
2242: final private boolean jj_3R_61() {
2243: if (jj_scan_token(DOT))
2244: return true;
2245: if (jj_scan_token(IDENTIFIER))
2246: return true;
2247: return false;
2248: }
2249:
2250: final private boolean jj_3_17() {
2251: if (jj_3R_23())
2252: return true;
2253: return false;
2254: }
2255:
2256: final private boolean jj_3R_46() {
2257: if (jj_scan_token(IDENTIFIER))
2258: return true;
2259: Token xsp;
2260: while (true) {
2261: xsp = jj_scanpos;
2262: if (jj_3R_61()) {
2263: jj_scanpos = xsp;
2264: break;
2265: }
2266: }
2267: return false;
2268: }
2269:
2270: final private boolean jj_3R_23() {
2271: Token xsp;
2272: xsp = jj_scanpos;
2273: if (jj_3R_36()) {
2274: jj_scanpos = xsp;
2275: if (jj_3R_37())
2276: return true;
2277: }
2278: return false;
2279: }
2280:
2281: final private boolean jj_3R_36() {
2282: if (jj_scan_token(LPAREN))
2283: return true;
2284: if (jj_3R_24())
2285: return true;
2286: if (jj_scan_token(LBRACKET))
2287: return true;
2288: if (jj_scan_token(RBRACKET))
2289: return true;
2290: return false;
2291: }
2292:
2293: final private boolean jj_3R_45() {
2294: if (jj_scan_token(BOOLEAN))
2295: return true;
2296: return false;
2297: }
2298:
2299: final private boolean jj_3R_18() {
2300: if (jj_3R_24())
2301: return true;
2302: return false;
2303: }
2304:
2305: final private boolean jj_3R_44() {
2306: if (jj_scan_token(DOUBLE))
2307: return true;
2308: return false;
2309: }
2310:
2311: final private boolean jj_3R_43() {
2312: if (jj_scan_token(FLOAT))
2313: return true;
2314: return false;
2315: }
2316:
2317: final private boolean jj_3R_42() {
2318: if (jj_scan_token(CHAR))
2319: return true;
2320: return false;
2321: }
2322:
2323: final private boolean jj_3R_41() {
2324: if (jj_scan_token(LONG))
2325: return true;
2326: return false;
2327: }
2328:
2329: final private boolean jj_3R_40() {
2330: if (jj_scan_token(SHORT))
2331: return true;
2332: return false;
2333: }
2334:
2335: final private boolean jj_3R_52() {
2336: if (jj_3R_68())
2337: return true;
2338: return false;
2339: }
2340:
2341: final private boolean jj_3R_39() {
2342: if (jj_scan_token(BYTE))
2343: return true;
2344: return false;
2345: }
2346:
2347: final private boolean jj_3R_38() {
2348: if (jj_scan_token(INT))
2349: return true;
2350: return false;
2351: }
2352:
2353: final private boolean jj_3R_24() {
2354: Token xsp;
2355: xsp = jj_scanpos;
2356: if (jj_3R_38()) {
2357: jj_scanpos = xsp;
2358: if (jj_3R_39()) {
2359: jj_scanpos = xsp;
2360: if (jj_3R_40()) {
2361: jj_scanpos = xsp;
2362: if (jj_3R_41()) {
2363: jj_scanpos = xsp;
2364: if (jj_3R_42()) {
2365: jj_scanpos = xsp;
2366: if (jj_3R_43()) {
2367: jj_scanpos = xsp;
2368: if (jj_3R_44()) {
2369: jj_scanpos = xsp;
2370: if (jj_3R_45()) {
2371: jj_scanpos = xsp;
2372: if (jj_3R_46())
2373: return true;
2374: }
2375: }
2376: }
2377: }
2378: }
2379: }
2380: }
2381: }
2382: return false;
2383: }
2384:
2385: final private boolean jj_3R_51() {
2386: if (jj_3R_67())
2387: return true;
2388: return false;
2389: }
2390:
2391: final private boolean jj_3R_66() {
2392: if (jj_scan_token(BANG))
2393: return true;
2394: return false;
2395: }
2396:
2397: final private boolean jj_3_1() {
2398: if (jj_scan_token(COMMA))
2399: return true;
2400: if (jj_3R_17())
2401: return true;
2402: return false;
2403: }
2404:
2405: final private boolean jj_3R_65() {
2406: if (jj_scan_token(TILDE))
2407: return true;
2408: return false;
2409: }
2410:
2411: final private boolean jj_3R_26() {
2412: Token xsp;
2413: xsp = jj_scanpos;
2414: if (jj_3R_50()) {
2415: jj_scanpos = xsp;
2416: if (jj_3R_51()) {
2417: jj_scanpos = xsp;
2418: if (jj_3R_52())
2419: return true;
2420: }
2421: }
2422: return false;
2423: }
2424:
2425: final private boolean jj_3R_50() {
2426: Token xsp;
2427: xsp = jj_scanpos;
2428: if (jj_3R_65()) {
2429: jj_scanpos = xsp;
2430: if (jj_3R_66())
2431: return true;
2432: }
2433: if (jj_3R_69())
2434: return true;
2435: return false;
2436: }
2437:
2438: final private boolean jj_3_14() {
2439: if (jj_scan_token(HAVING))
2440: return true;
2441: return false;
2442: }
2443:
2444: final private boolean jj_3_13() {
2445: if (jj_scan_token(COMMA))
2446: return true;
2447: return false;
2448: }
2449:
2450: final private boolean jj_3R_106() {
2451: if (jj_scan_token(COMMA))
2452: return true;
2453: if (jj_3R_62())
2454: return true;
2455: return false;
2456: }
2457:
2458: final private boolean jj_3R_79() {
2459: if (jj_3R_26())
2460: return true;
2461: return false;
2462: }
2463:
2464: final private boolean jj_3R_103() {
2465: if (jj_scan_token(MINUS))
2466: return true;
2467: return false;
2468: }
2469:
2470: final private boolean jj_3R_102() {
2471: if (jj_scan_token(PLUS))
2472: return true;
2473: return false;
2474: }
2475:
2476: final private boolean jj_3R_78() {
2477: Token xsp;
2478: xsp = jj_scanpos;
2479: if (jj_3R_102()) {
2480: jj_scanpos = xsp;
2481: if (jj_3R_103())
2482: return true;
2483: }
2484: if (jj_3R_69())
2485: return true;
2486: return false;
2487: }
2488:
2489: final private boolean jj_3R_69() {
2490: Token xsp;
2491: xsp = jj_scanpos;
2492: if (jj_3R_78()) {
2493: jj_scanpos = xsp;
2494: if (jj_3R_79())
2495: return true;
2496: }
2497: return false;
2498: }
2499:
2500: final private boolean jj_3R_76() {
2501: if (jj_3R_91())
2502: return true;
2503: return false;
2504: }
2505:
2506: final private boolean jj_3R_17() {
2507: if (jj_3R_24())
2508: return true;
2509: return false;
2510: }
2511:
2512: final private boolean jj_3R_91() {
2513: if (jj_3R_62())
2514: return true;
2515: Token xsp;
2516: while (true) {
2517: xsp = jj_scanpos;
2518: if (jj_3R_106()) {
2519: jj_scanpos = xsp;
2520: break;
2521: }
2522: }
2523: return false;
2524: }
2525:
2526: final private boolean jj_3R_64() {
2527: if (jj_scan_token(LPAREN))
2528: return true;
2529: Token xsp;
2530: xsp = jj_scanpos;
2531: if (jj_3R_76())
2532: jj_scanpos = xsp;
2533: if (jj_scan_token(RPAREN))
2534: return true;
2535: return false;
2536: }
2537:
2538: final private boolean jj_3R_81() {
2539: if (jj_scan_token(SLASH))
2540: return true;
2541: return false;
2542: }
2543:
2544: final private boolean jj_3R_49() {
2545: if (jj_3R_64())
2546: return true;
2547: return false;
2548: }
2549:
2550: final private boolean jj_3R_48() {
2551: if (jj_scan_token(DOT))
2552: return true;
2553: if (jj_3R_63())
2554: return true;
2555: return false;
2556: }
2557:
2558: final private boolean jj_3R_80() {
2559: if (jj_scan_token(STAR))
2560: return true;
2561: return false;
2562: }
2563:
2564: final private boolean jj_3R_70() {
2565: Token xsp;
2566: xsp = jj_scanpos;
2567: if (jj_3R_80()) {
2568: jj_scanpos = xsp;
2569: if (jj_3R_81())
2570: return true;
2571: }
2572: if (jj_3R_69())
2573: return true;
2574: return false;
2575: }
2576:
2577: final private boolean jj_3R_53() {
2578: if (jj_3R_69())
2579: return true;
2580: return false;
2581: }
2582:
2583: final private boolean jj_3R_54() {
2584: if (jj_3R_69())
2585: return true;
2586: Token xsp;
2587: while (true) {
2588: xsp = jj_scanpos;
2589: if (jj_3R_70()) {
2590: jj_scanpos = xsp;
2591: break;
2592: }
2593: }
2594: return false;
2595: }
2596:
2597: final private boolean jj_3R_25() {
2598: Token xsp;
2599: xsp = jj_scanpos;
2600: if (jj_3R_47()) {
2601: jj_scanpos = xsp;
2602: if (jj_3R_48()) {
2603: jj_scanpos = xsp;
2604: if (jj_3R_49())
2605: return true;
2606: }
2607: }
2608: return false;
2609: }
2610:
2611: final private boolean jj_3R_47() {
2612: if (jj_scan_token(LBRACKET))
2613: return true;
2614: if (jj_3R_62())
2615: return true;
2616: if (jj_scan_token(RBRACKET))
2617: return true;
2618: return false;
2619: }
2620:
2621: final private boolean jj_3_12() {
2622: if (jj_scan_token(MAX))
2623: return true;
2624: return false;
2625: }
2626:
2627: final private boolean jj_3R_101() {
2628: if (jj_scan_token(LPAREN))
2629: return true;
2630: if (jj_3R_62())
2631: return true;
2632: if (jj_scan_token(RPAREN))
2633: return true;
2634: return false;
2635: }
2636:
2637: final private boolean jj_3_11() {
2638: if (jj_scan_token(MIN))
2639: return true;
2640: return false;
2641: }
2642:
2643: final private boolean jj_3_10() {
2644: if (jj_scan_token(SUM))
2645: return true;
2646: return false;
2647: }
2648:
2649: final private boolean jj_3R_72() {
2650: if (jj_scan_token(MINUS))
2651: return true;
2652: return false;
2653: }
2654:
2655: final private boolean jj_3_9() {
2656: if (jj_scan_token(AVG))
2657: return true;
2658: return false;
2659: }
2660:
2661: final private boolean jj_3R_71() {
2662: if (jj_scan_token(PLUS))
2663: return true;
2664: return false;
2665: }
2666:
2667: final private boolean jj_3_8() {
2668: if (jj_scan_token(COUNT))
2669: return true;
2670: return false;
2671: }
2672:
2673: final private boolean jj_3R_33() {
2674: if (jj_3R_53())
2675: return true;
2676: return false;
2677: }
2678:
2679: final private boolean jj_3R_55() {
2680: Token xsp;
2681: xsp = jj_scanpos;
2682: if (jj_3R_71()) {
2683: jj_scanpos = xsp;
2684: if (jj_3R_72())
2685: return true;
2686: }
2687: if (jj_3R_54())
2688: return true;
2689: return false;
2690: }
2691:
2692: final private boolean jj_3_7() {
2693: if (jj_scan_token(COUNT_STAR))
2694: return true;
2695: return false;
2696: }
2697:
2698: final private boolean jj_3R_32() {
2699: if (jj_scan_token(MAX))
2700: return true;
2701: return false;
2702: }
2703:
2704: final private boolean jj_3R_100() {
2705: if (jj_scan_token(THIS))
2706: return true;
2707: return false;
2708: }
2709:
2710: final private boolean jj_3R_99() {
2711: if (jj_3R_63())
2712: return true;
2713: return false;
2714: }
2715:
2716: final private boolean jj_3R_31() {
2717: if (jj_scan_token(MIN))
2718: return true;
2719: return false;
2720: }
2721:
2722: final private boolean jj_3R_34() {
2723: if (jj_3R_54())
2724: return true;
2725: Token xsp;
2726: while (true) {
2727: xsp = jj_scanpos;
2728: if (jj_3R_55()) {
2729: jj_scanpos = xsp;
2730: break;
2731: }
2732: }
2733: return false;
2734: }
2735:
2736: final private boolean jj_3R_98() {
2737: if (jj_3R_73())
2738: return true;
2739: return false;
2740: }
2741:
2742: final private boolean jj_3R_30() {
2743: if (jj_scan_token(SUM))
2744: return true;
2745: return false;
2746: }
2747:
2748: final private boolean jj_3_26() {
2749: if (jj_scan_token(MAX))
2750: return true;
2751: return false;
2752: }
2753:
2754: final private boolean jj_3R_29() {
2755: if (jj_scan_token(AVG))
2756: return true;
2757: return false;
2758: }
2759:
2760: final private boolean jj_3R_59() {
2761: if (jj_scan_token(GE))
2762: return true;
2763: return false;
2764: }
2765:
2766: final private boolean jj_3R_58() {
2767: if (jj_scan_token(LE))
2768: return true;
2769: return false;
2770: }
2771:
2772: final private boolean jj_3R_28() {
2773: if (jj_scan_token(COUNT))
2774: return true;
2775: return false;
2776: }
2777:
2778: final private boolean jj_3_5() {
2779: if (jj_scan_token(COMMA))
2780: return true;
2781: if (jj_3R_20())
2782: return true;
2783: return false;
2784: }
2785:
2786: final private boolean jj_3R_56() {
2787: if (jj_scan_token(LT))
2788: return true;
2789: return false;
2790: }
2791:
2792: final private boolean jj_3R_21() {
2793: Token xsp;
2794: xsp = jj_scanpos;
2795: if (jj_3R_27()) {
2796: jj_scanpos = xsp;
2797: if (jj_3R_28()) {
2798: jj_scanpos = xsp;
2799: if (jj_3R_29()) {
2800: jj_scanpos = xsp;
2801: if (jj_3R_30()) {
2802: jj_scanpos = xsp;
2803: if (jj_3R_31()) {
2804: jj_scanpos = xsp;
2805: if (jj_3R_32()) {
2806: jj_scanpos = xsp;
2807: if (jj_3R_33())
2808: return true;
2809: }
2810: }
2811: }
2812: }
2813: }
2814: }
2815: return false;
2816: }
2817:
2818: final private boolean jj_3R_27() {
2819: if (jj_scan_token(COUNT_STAR))
2820: return true;
2821: return false;
2822: }
2823:
2824: final private boolean jj_3_25() {
2825: if (jj_scan_token(MIN))
2826: return true;
2827: return false;
2828: }
2829:
2830: final private boolean jj_3R_35() {
2831: Token xsp;
2832: xsp = jj_scanpos;
2833: if (jj_3R_56()) {
2834: jj_scanpos = xsp;
2835: if (jj_3R_57()) {
2836: jj_scanpos = xsp;
2837: if (jj_3R_58()) {
2838: jj_scanpos = xsp;
2839: if (jj_3R_59())
2840: return true;
2841: }
2842: }
2843: }
2844: if (jj_3R_34())
2845: return true;
2846: return false;
2847: }
2848:
2849: final private boolean jj_3R_57() {
2850: if (jj_scan_token(GT))
2851: return true;
2852: return false;
2853: }
2854:
2855: final private boolean jj_3R_97() {
2856: if (jj_scan_token(MAX))
2857: return true;
2858: if (jj_3R_69())
2859: return true;
2860: return false;
2861: }
2862:
2863: final private boolean jj_3_6() {
2864: if (jj_scan_token(COMMA))
2865: return true;
2866: if (jj_3R_21())
2867: return true;
2868: return false;
2869: }
2870:
2871: final private boolean jj_3_24() {
2872: if (jj_scan_token(SUM))
2873: return true;
2874: return false;
2875: }
2876:
2877: final private boolean jj_3R_96() {
2878: if (jj_scan_token(MIN))
2879: return true;
2880: if (jj_3R_69())
2881: return true;
2882: return false;
2883: }
2884:
2885: final private boolean jj_3_23() {
2886: if (jj_scan_token(AVG))
2887: return true;
2888: return false;
2889: }
2890:
2891: final private boolean jj_3_21() {
2892: if (jj_scan_token(COUNT_STAR))
2893: return true;
2894: return false;
2895: }
2896:
2897: final private boolean jj_3R_95() {
2898: if (jj_scan_token(SUM))
2899: return true;
2900: if (jj_3R_69())
2901: return true;
2902: return false;
2903: }
2904:
2905: final private boolean jj_3_22() {
2906: if (jj_scan_token(COUNT))
2907: return true;
2908: return false;
2909: }
2910:
2911: final private boolean jj_3R_108() {
2912: if (jj_scan_token(NE))
2913: return true;
2914: if (jj_3R_22())
2915: return true;
2916: return false;
2917: }
2918:
2919: final private boolean jj_3R_22() {
2920: if (jj_3R_34())
2921: return true;
2922: Token xsp;
2923: xsp = jj_scanpos;
2924: if (jj_3R_35())
2925: jj_scanpos = xsp;
2926: return false;
2927: }
2928:
2929: final private boolean jj_3R_94() {
2930: if (jj_scan_token(AVG))
2931: return true;
2932: if (jj_3R_69())
2933: return true;
2934: return false;
2935: }
2936:
2937: final private boolean jj_3R_92() {
2938: if (jj_scan_token(COUNT_STAR))
2939: return true;
2940: return false;
2941: }
2942:
2943: final private boolean jj_3R_77() {
2944: Token xsp;
2945: xsp = jj_scanpos;
2946: if (jj_3R_92()) {
2947: jj_scanpos = xsp;
2948: if (jj_3R_93()) {
2949: jj_scanpos = xsp;
2950: if (jj_3R_94()) {
2951: jj_scanpos = xsp;
2952: if (jj_3R_95()) {
2953: jj_scanpos = xsp;
2954: if (jj_3R_96()) {
2955: jj_scanpos = xsp;
2956: if (jj_3R_97()) {
2957: jj_scanpos = xsp;
2958: if (jj_3R_98()) {
2959: jj_scanpos = xsp;
2960: if (jj_3R_99()) {
2961: jj_scanpos = xsp;
2962: if (jj_3R_100()) {
2963: jj_scanpos = xsp;
2964: if (jj_3R_101())
2965: return true;
2966: }
2967: }
2968: }
2969: }
2970: }
2971: }
2972: }
2973: }
2974: }
2975: return false;
2976: }
2977:
2978: final private boolean jj_3R_93() {
2979: if (jj_scan_token(COUNT))
2980: return true;
2981: if (jj_3R_69())
2982: return true;
2983: return false;
2984: }
2985:
2986: final private boolean jj_3_16() {
2987: if (jj_3R_22())
2988: return true;
2989: if (jj_scan_token(EQ))
2990: return true;
2991: return false;
2992: }
2993:
2994: final private boolean jj_3R_105() {
2995: if (jj_3R_22())
2996: return true;
2997: Token xsp;
2998: xsp = jj_scanpos;
2999: if (jj_3R_108())
3000: jj_scanpos = xsp;
3001: return false;
3002: }
3003:
3004: final private boolean jj_3R_107() {
3005: if (jj_scan_token(EQ))
3006: return true;
3007: if (jj_3R_22())
3008: return true;
3009: return false;
3010: }
3011:
3012: final private boolean jj_3R_20() {
3013: if (jj_3R_26())
3014: return true;
3015: return false;
3016: }
3017:
3018: final private boolean jj_3R_87() {
3019: if (jj_scan_token(CHARACTER_LITERAL))
3020: return true;
3021: return false;
3022: }
3023:
3024: final private boolean jj_3R_109() {
3025: if (jj_3R_104())
3026: return true;
3027: return false;
3028: }
3029:
3030: final private boolean jj_3R_86() {
3031: if (jj_scan_token(STRING_LITERAL))
3032: return true;
3033: return false;
3034: }
3035:
3036: final private boolean jj_3R_104() {
3037: if (jj_3R_22())
3038: return true;
3039: Token xsp;
3040: xsp = jj_scanpos;
3041: if (jj_3R_107())
3042: jj_scanpos = xsp;
3043: return false;
3044: }
3045:
3046: final private boolean jj_3R_85() {
3047: if (jj_scan_token(NULL))
3048: return true;
3049: return false;
3050: }
3051:
3052: final private boolean jj_3R_110() {
3053: if (jj_3R_105())
3054: return true;
3055: return false;
3056: }
3057:
3058: final private boolean jj_3R_84() {
3059: if (jj_scan_token(BOOLEAN_LITERAL))
3060: return true;
3061: return false;
3062: }
3063:
3064: final private boolean jj_3R_83() {
3065: if (jj_scan_token(FLOATING_POINT_LITERAL))
3066: return true;
3067: return false;
3068: }
3069:
3070: final private boolean jj_3_4() {
3071: if (jj_scan_token(DOT))
3072: return true;
3073: if (jj_scan_token(IDENTIFIER))
3074: return true;
3075: return false;
3076: }
3077:
3078: final private boolean jj_3_15() {
3079: if (jj_3R_22())
3080: return true;
3081: if (jj_scan_token(EQ))
3082: return true;
3083: return false;
3084: }
3085:
3086: final private boolean jj_3R_82() {
3087: if (jj_scan_token(INTEGER_LITERAL))
3088: return true;
3089: return false;
3090: }
3091:
3092: final private boolean jj_3R_60() {
3093: if (jj_3R_73())
3094: return true;
3095: return false;
3096: }
3097:
3098: final private boolean jj_3R_73() {
3099: Token xsp;
3100: xsp = jj_scanpos;
3101: if (jj_3R_82()) {
3102: jj_scanpos = xsp;
3103: if (jj_3R_83()) {
3104: jj_scanpos = xsp;
3105: if (jj_3R_84()) {
3106: jj_scanpos = xsp;
3107: if (jj_3R_85()) {
3108: jj_scanpos = xsp;
3109: if (jj_3R_86()) {
3110: jj_scanpos = xsp;
3111: if (jj_3R_87())
3112: return true;
3113: }
3114: }
3115: }
3116: }
3117: }
3118: return false;
3119: }
3120:
3121: final private boolean jj_3R_90() {
3122: Token xsp;
3123: xsp = jj_scanpos;
3124: if (jj_scan_token(63)) {
3125: jj_scanpos = xsp;
3126: if (jj_scan_token(68))
3127: return true;
3128: }
3129: xsp = jj_scanpos;
3130: if (jj_3R_109()) {
3131: jj_scanpos = xsp;
3132: if (jj_3R_110())
3133: return true;
3134: }
3135: return false;
3136: }
3137:
3138: final private boolean jj_3R_89() {
3139: if (jj_3R_105())
3140: return true;
3141: return false;
3142: }
3143:
3144: final private boolean jj_3R_88() {
3145: if (jj_3R_104())
3146: return true;
3147: return false;
3148: }
3149:
3150: final private boolean jj_3R_19() {
3151: if (jj_scan_token(IMPORT))
3152: return true;
3153: return false;
3154: }
3155:
3156: final private boolean jj_3R_74() {
3157: Token xsp;
3158: xsp = jj_scanpos;
3159: if (jj_3R_88()) {
3160: jj_scanpos = xsp;
3161: if (jj_3R_89())
3162: return true;
3163: }
3164: while (true) {
3165: xsp = jj_scanpos;
3166: if (jj_3R_90()) {
3167: jj_scanpos = xsp;
3168: break;
3169: }
3170: }
3171: return false;
3172: }
3173:
3174: final private boolean jj_3_20() {
3175: if (jj_3R_25())
3176: return true;
3177: return false;
3178: }
3179:
3180: final private boolean jj_3_3() {
3181: if (jj_scan_token(SEMICOLON))
3182: return true;
3183: if (jj_3R_19())
3184: return true;
3185: return false;
3186: }
3187:
3188: public JDOQLParserTokenManager token_source;
3189: JavaCharStream jj_input_stream;
3190: public Token token, jj_nt;
3191: private int jj_ntk;
3192: private Token jj_scanpos, jj_lastpos;
3193: private int jj_la;
3194: public boolean lookingAhead = false;
3195: private boolean jj_semLA;
3196: private int jj_gen;
3197: final private int[] jj_la1 = new int[44];
3198: static private int[] jj_la1_0;
3199: static private int[] jj_la1_1;
3200: static private int[] jj_la1_2;
3201: static {
3202: jj_la1_0();
3203: jj_la1_1();
3204: jj_la1_2();
3205: }
3206:
3207: private static void jj_la1_0() {
3208: jj_la1_0 = new int[] { 0x0, 0x76e00001, 0x0, 0x76e00001, 0x0,
3209: 0x8000001, 0x0, 0x0, 0x800fc001, 0x1000400, 0x800,
3210: 0x100000, 0x800fc000, 0x100000, 0x80000000, 0x800fc001,
3211: 0x0, 0x0, 0x800fc000, 0x0, 0x0, 0x800fc000, 0x0, 0x0,
3212: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x800fc000, 0x0,
3213: 0x0, 0x800fc000, 0x80000000, 0x0, 0x80000000, 0x0,
3214: 0x800fc000, 0x0, 0x0, 0x76e00000, 0x0, };
3215: }
3216:
3217: private static void jj_la1_1() {
3218: jj_la1_1 = new int[] { 0x100000, 0x400, 0x80000, 0x400,
3219: 0x80000, 0x0, 0x200000, 0x100000, 0x30027d1, 0x0, 0x0,
3220: 0x0, 0x30027d1, 0x0, 0x400, 0x30027d1, 0x40000000,
3221: 0x40000000, 0x30027d1, 0x80000000, 0x80000000,
3222: 0x30027d1, 0x4000000, 0x20000000, 0x18c00000,
3223: 0x18c00000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30027d1,
3224: 0x3000000, 0x3000000, 0x27d1, 0x30027d1, 0x2000,
3225: 0x27d1, 0x222000, 0x30027d1, 0x100000, 0x200000, 0x400,
3226: 0x3d1, };
3227: }
3228:
3229: private static void jj_la1_2() {
3230: jj_la1_2 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3231: 0x0, 0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x3, 0x20, 0x20,
3232: 0x3, 0x10, 0x10, 0x3, 0x0, 0x0, 0x0, 0x0, 0x3, 0x3,
3233: 0xc, 0xc, 0x3, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3234: 0x3, 0x0, 0x0, 0x0, 0x0, };
3235: }
3236:
3237: final private JJCalls[] jj_2_rtns = new JJCalls[27];
3238: private boolean jj_rescan = false;
3239: private int jj_gc = 0;
3240:
3241: public JDOQLParser(java.io.InputStream stream) {
3242: jj_input_stream = new JavaCharStream(stream, 1, 1);
3243: token_source = new JDOQLParserTokenManager(jj_input_stream);
3244: token = new Token();
3245: jj_ntk = -1;
3246: jj_gen = 0;
3247: for (int i = 0; i < 44; i++)
3248: jj_la1[i] = -1;
3249: for (int i = 0; i < jj_2_rtns.length; i++)
3250: jj_2_rtns[i] = new JJCalls();
3251: }
3252:
3253: public void ReInit(java.io.InputStream stream) {
3254: jj_input_stream.ReInit(stream, 1, 1);
3255: token_source.ReInit(jj_input_stream);
3256: token = new Token();
3257: jj_ntk = -1;
3258: jj_gen = 0;
3259: for (int i = 0; i < 44; i++)
3260: jj_la1[i] = -1;
3261: for (int i = 0; i < jj_2_rtns.length; i++)
3262: jj_2_rtns[i] = new JJCalls();
3263: }
3264:
3265: public JDOQLParser(java.io.Reader stream) {
3266: jj_input_stream = new JavaCharStream(stream, 1, 1);
3267: token_source = new JDOQLParserTokenManager(jj_input_stream);
3268: token = new Token();
3269: jj_ntk = -1;
3270: jj_gen = 0;
3271: for (int i = 0; i < 44; i++)
3272: jj_la1[i] = -1;
3273: for (int i = 0; i < jj_2_rtns.length; i++)
3274: jj_2_rtns[i] = new JJCalls();
3275: }
3276:
3277: public void ReInit(java.io.Reader stream) {
3278: jj_input_stream.ReInit(stream, 1, 1);
3279: token_source.ReInit(jj_input_stream);
3280: token = new Token();
3281: jj_ntk = -1;
3282: jj_gen = 0;
3283: for (int i = 0; i < 44; i++)
3284: jj_la1[i] = -1;
3285: for (int i = 0; i < jj_2_rtns.length; i++)
3286: jj_2_rtns[i] = new JJCalls();
3287: }
3288:
3289: public JDOQLParser(JDOQLParserTokenManager tm) {
3290: token_source = tm;
3291: token = new Token();
3292: jj_ntk = -1;
3293: jj_gen = 0;
3294: for (int i = 0; i < 44; i++)
3295: jj_la1[i] = -1;
3296: for (int i = 0; i < jj_2_rtns.length; i++)
3297: jj_2_rtns[i] = new JJCalls();
3298: }
3299:
3300: public void ReInit(JDOQLParserTokenManager tm) {
3301: token_source = tm;
3302: token = new Token();
3303: jj_ntk = -1;
3304: jj_gen = 0;
3305: for (int i = 0; i < 44; i++)
3306: jj_la1[i] = -1;
3307: for (int i = 0; i < jj_2_rtns.length; i++)
3308: jj_2_rtns[i] = new JJCalls();
3309: }
3310:
3311: final private Token jj_consume_token(int kind)
3312: throws ParseException {
3313: Token oldToken;
3314: if ((oldToken = token).next != null)
3315: token = token.next;
3316: else
3317: token = token.next = token_source.getNextToken();
3318: jj_ntk = -1;
3319: if (token.kind == kind) {
3320: jj_gen++;
3321: if (++jj_gc > 100) {
3322: jj_gc = 0;
3323: for (int i = 0; i < jj_2_rtns.length; i++) {
3324: JJCalls c = jj_2_rtns[i];
3325: while (c != null) {
3326: if (c.gen < jj_gen)
3327: c.first = null;
3328: c = c.next;
3329: }
3330: }
3331: }
3332: return token;
3333: }
3334: token = oldToken;
3335: jj_kind = kind;
3336: throw generateParseException();
3337: }
3338:
3339: static private final class LookaheadSuccess extends java.lang.Error {
3340: }
3341:
3342: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3343:
3344: final private boolean jj_scan_token(int kind) {
3345: if (jj_scanpos == jj_lastpos) {
3346: jj_la--;
3347: if (jj_scanpos.next == null) {
3348: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
3349: .getNextToken();
3350: } else {
3351: jj_lastpos = jj_scanpos = jj_scanpos.next;
3352: }
3353: } else {
3354: jj_scanpos = jj_scanpos.next;
3355: }
3356: if (jj_rescan) {
3357: int i = 0;
3358: Token tok = token;
3359: while (tok != null && tok != jj_scanpos) {
3360: i++;
3361: tok = tok.next;
3362: }
3363: if (tok != null)
3364: jj_add_error_token(kind, i);
3365: }
3366: if (jj_scanpos.kind != kind)
3367: return true;
3368: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3369: throw jj_ls;
3370: return false;
3371: }
3372:
3373: final public Token getNextToken() {
3374: if (token.next != null)
3375: token = token.next;
3376: else
3377: token = token.next = token_source.getNextToken();
3378: jj_ntk = -1;
3379: jj_gen++;
3380: return token;
3381: }
3382:
3383: final public Token getToken(int index) {
3384: Token t = lookingAhead ? jj_scanpos : token;
3385: for (int i = 0; i < index; i++) {
3386: if (t.next != null)
3387: t = t.next;
3388: else
3389: t = t.next = token_source.getNextToken();
3390: }
3391: return t;
3392: }
3393:
3394: final private int jj_ntk() {
3395: if ((jj_nt = token.next) == null)
3396: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
3397: else
3398: return (jj_ntk = jj_nt.kind);
3399: }
3400:
3401: private java.util.Vector jj_expentries = new java.util.Vector();
3402: private int[] jj_expentry;
3403: private int jj_kind = -1;
3404: private int[] jj_lasttokens = new int[100];
3405: private int jj_endpos;
3406:
3407: private void jj_add_error_token(int kind, int pos) {
3408: if (pos >= 100)
3409: return;
3410: if (pos == jj_endpos + 1) {
3411: jj_lasttokens[jj_endpos++] = kind;
3412: } else if (jj_endpos != 0) {
3413: jj_expentry = new int[jj_endpos];
3414: for (int i = 0; i < jj_endpos; i++) {
3415: jj_expentry[i] = jj_lasttokens[i];
3416: }
3417: boolean exists = false;
3418: for (java.util.Enumeration e = jj_expentries.elements(); e
3419: .hasMoreElements();) {
3420: int[] oldentry = (int[]) (e.nextElement());
3421: if (oldentry.length == jj_expentry.length) {
3422: exists = true;
3423: for (int i = 0; i < jj_expentry.length; i++) {
3424: if (oldentry[i] != jj_expentry[i]) {
3425: exists = false;
3426: break;
3427: }
3428: }
3429: if (exists)
3430: break;
3431: }
3432: }
3433: if (!exists)
3434: jj_expentries.addElement(jj_expentry);
3435: if (pos != 0)
3436: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3437: }
3438: }
3439:
3440: public ParseException generateParseException() {
3441: jj_expentries.removeAllElements();
3442: boolean[] la1tokens = new boolean[70];
3443: for (int i = 0; i < 70; i++) {
3444: la1tokens[i] = false;
3445: }
3446: if (jj_kind >= 0) {
3447: la1tokens[jj_kind] = true;
3448: jj_kind = -1;
3449: }
3450: for (int i = 0; i < 44; i++) {
3451: if (jj_la1[i] == jj_gen) {
3452: for (int j = 0; j < 32; j++) {
3453: if ((jj_la1_0[i] & (1 << j)) != 0) {
3454: la1tokens[j] = true;
3455: }
3456: if ((jj_la1_1[i] & (1 << j)) != 0) {
3457: la1tokens[32 + j] = true;
3458: }
3459: if ((jj_la1_2[i] & (1 << j)) != 0) {
3460: la1tokens[64 + j] = true;
3461: }
3462: }
3463: }
3464: }
3465: for (int i = 0; i < 70; i++) {
3466: if (la1tokens[i]) {
3467: jj_expentry = new int[1];
3468: jj_expentry[0] = i;
3469: jj_expentries.addElement(jj_expentry);
3470: }
3471: }
3472: jj_endpos = 0;
3473: jj_rescan_token();
3474: jj_add_error_token(0, 0);
3475: int[][] exptokseq = new int[jj_expentries.size()][];
3476: for (int i = 0; i < jj_expentries.size(); i++) {
3477: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
3478: }
3479: return new ParseException(token, exptokseq, tokenImage);
3480: }
3481:
3482: final public void enable_tracing() {
3483: }
3484:
3485: final public void disable_tracing() {
3486: }
3487:
3488: final private void jj_rescan_token() {
3489: jj_rescan = true;
3490: for (int i = 0; i < 27; i++) {
3491: JJCalls p = jj_2_rtns[i];
3492: do {
3493: if (p.gen > jj_gen) {
3494: jj_la = p.arg;
3495: jj_lastpos = jj_scanpos = p.first;
3496: switch (i) {
3497: case 0:
3498: jj_3_1();
3499: break;
3500: case 1:
3501: jj_3_2();
3502: break;
3503: case 2:
3504: jj_3_3();
3505: break;
3506: case 3:
3507: jj_3_4();
3508: break;
3509: case 4:
3510: jj_3_5();
3511: break;
3512: case 5:
3513: jj_3_6();
3514: break;
3515: case 6:
3516: jj_3_7();
3517: break;
3518: case 7:
3519: jj_3_8();
3520: break;
3521: case 8:
3522: jj_3_9();
3523: break;
3524: case 9:
3525: jj_3_10();
3526: break;
3527: case 10:
3528: jj_3_11();
3529: break;
3530: case 11:
3531: jj_3_12();
3532: break;
3533: case 12:
3534: jj_3_13();
3535: break;
3536: case 13:
3537: jj_3_14();
3538: break;
3539: case 14:
3540: jj_3_15();
3541: break;
3542: case 15:
3543: jj_3_16();
3544: break;
3545: case 16:
3546: jj_3_17();
3547: break;
3548: case 17:
3549: jj_3_18();
3550: break;
3551: case 18:
3552: jj_3_19();
3553: break;
3554: case 19:
3555: jj_3_20();
3556: break;
3557: case 20:
3558: jj_3_21();
3559: break;
3560: case 21:
3561: jj_3_22();
3562: break;
3563: case 22:
3564: jj_3_23();
3565: break;
3566: case 23:
3567: jj_3_24();
3568: break;
3569: case 24:
3570: jj_3_25();
3571: break;
3572: case 25:
3573: jj_3_26();
3574: break;
3575: case 26:
3576: jj_3_27();
3577: break;
3578: }
3579: }
3580: p = p.next;
3581: } while (p != null);
3582: }
3583: jj_rescan = false;
3584: }
3585:
3586: final private void jj_save(int index, int xla) {
3587: JJCalls p = jj_2_rtns[index];
3588: while (p.gen > jj_gen) {
3589: if (p.next == null) {
3590: p = p.next = new JJCalls();
3591: break;
3592: }
3593: p = p.next;
3594: }
3595: p.gen = jj_gen + xla - jj_la;
3596: p.first = token;
3597: p.arg = xla;
3598: }
3599:
3600: static final class JJCalls {
3601: int gen;
3602: Token first;
3603: int arg;
3604: JJCalls next;
3605: }
3606:
3607: }
|