00001: /*
00002: * $Id: ParserBase.java,v 1.95 2002/09/16 08:05:05 jkl Exp $
00003: *
00004: * Copyright (c) 2002 Njet Communications Ltd. All Rights Reserved.
00005: *
00006: * Use is subject to license terms, as defined in
00007: * Anvil Sofware License, Version 1.1. See LICENSE
00008: * file, or http://njet.org/license-1.1.txt
00009: */
00010: package anvil.script.parser;
00011:
00012: import anvil.core.Any;
00013: import anvil.core.AnyPattern;
00014: import anvil.core.ObjectPool;
00015: import anvil.core.LangModule;
00016: import anvil.ErrorListener;
00017: import anvil.Location;
00018: import anvil.script.ClassType;
00019: import anvil.script.ClassRef;
00020: import anvil.script.ConstantVariableType;
00021: import anvil.script.Context;
00022: import anvil.script.CompilableFunction;
00023: import anvil.script.Name;
00024: import anvil.script.Type;
00025: import anvil.script.expression.AdditionAssignmentNode;
00026: import anvil.script.expression.AdditionNode;
00027: import anvil.script.expression.AndNode;
00028: import anvil.script.expression.ArrayNode;
00029: import anvil.script.expression.ArrayComprehensionNode;
00030: import anvil.script.expression.ComprehensionNode;
00031: import anvil.script.expression.ListComprehensionNode;
00032: import anvil.script.expression.AssignmentNode;
00033: import anvil.script.expression.AttributeNode;
00034: import anvil.script.expression.BooleanCastNode;
00035: import anvil.script.expression.CallNode;
00036: import anvil.script.expression.ChainedComparisonNode;
00037: import anvil.script.expression.ClassOfNode;
00038: import anvil.script.expression.CompareNode;
00039: import anvil.script.expression.ConcatenationAssignmentNode;
00040: import anvil.script.expression.ConcatenationNode;
00041: import anvil.script.expression.ConditionalNode;
00042: import anvil.script.expression.ConstantNode;
00043: import anvil.script.expression.ConstructorInvokeNode;
00044: import anvil.script.expression.CopyNode;
00045: import anvil.script.expression.CloneNode;
00046: import anvil.script.expression.DefinedNode;
00047: import anvil.script.expression.DeleteNode;
00048: import anvil.script.expression.TypeNode;
00049: import anvil.script.expression.DivisionAssignmentNode;
00050: import anvil.script.expression.DivisionNode;
00051: import anvil.script.expression.DynamicCallNode;
00052: import anvil.script.expression.DynamicInvokeNode;
00053: import anvil.script.expression.DynamicHasNode;
00054: import anvil.script.expression.EmptyReferenceNode;
00055: import anvil.script.expression.EnumerationNode;
00056: import anvil.script.expression.EqualToNode;
00057: import anvil.script.expression.ExactCompareNode;
00058: import anvil.script.expression.ExactEqualToNode;
00059: import anvil.script.expression.ExactNotEqualToNode;
00060: import anvil.script.expression.Expression;
00061: import anvil.script.expression.ExpressionList;
00062: import anvil.script.expression.MutableExpressionList;
00063: import anvil.script.expression.FloatCastNode;
00064: import anvil.script.expression.GreaterThanNode;
00065: import anvil.script.expression.GreaterThanOrEqualToNode;
00066: import anvil.script.expression.HasNode;
00067: import anvil.script.expression.ImportNode;
00068: import anvil.script.expression.InNode;
00069: import anvil.script.expression.InitAssignmentNode;
00070: import anvil.script.expression.IntCastNode;
00071: import anvil.script.expression.InvokeNode;
00072: import anvil.script.expression.InlinedFunctionNode;
00073: import anvil.script.expression.InstanceOfNode;
00074: import anvil.script.expression.IsNode;
00075: import anvil.script.expression.LessThanNode;
00076: import anvil.script.expression.LessThanOrEqualToNode;
00077: import anvil.script.expression.MappingNode;
00078: import anvil.script.expression.MatchNode;
00079: import anvil.script.expression.ModuloAssignmentNode;
00080: import anvil.script.expression.ModuloNode;
00081: import anvil.script.expression.MultiplicationAssignmentNode;
00082: import anvil.script.expression.MultiplicationNode;
00083: import anvil.script.expression.NamedNode;
00084: import anvil.script.expression.NewNode;
00085: import anvil.script.expression.Node;
00086: import anvil.script.expression.NoMatchNode;
00087: import anvil.script.expression.NotEqualToNode;
00088: import anvil.script.expression.OrNode;
00089: import anvil.script.expression.Parent;
00090: import anvil.script.expression.PipeNode;
00091: import anvil.script.expression.PostfixDecrementNode;
00092: import anvil.script.expression.PostfixIncrementNode;
00093: import anvil.script.expression.PrefixDecrementNode;
00094: import anvil.script.expression.PrefixIncrementNode;
00095: import anvil.script.expression.RangeNode;
00096: import anvil.script.expression.RefNode;
00097: import anvil.script.expression.ReferenceNode;
00098: import anvil.script.expression.SelectNode;
00099: import anvil.script.expression.SizeOfNode;
00100: import anvil.script.expression.SpliceNode;
00101: import anvil.script.expression.StringCastNode;
00102: import anvil.script.expression.SubtractionAssignmentNode;
00103: import anvil.script.expression.SubtractionNode;
00104: import anvil.script.expression.SuperInvokeNode;
00105: import anvil.script.expression.SymbolNode;
00106: import anvil.script.expression.ThisNode;
00107: import anvil.script.expression.TypeOfNode;
00108: import anvil.script.expression.UnaryMinusNode;
00109: import anvil.script.expression.UnaryNegateNode;
00110: import anvil.script.expression.UnaryPlusNode;
00111: import anvil.script.expression.LinkNode;
00112: import anvil.script.expression.VariableNode;
00113: import anvil.script.expression.XorNode;
00114: import anvil.script.expression.ThunkNode;
00115: import anvil.script.expression.ForeachNode;
00116: import anvil.script.InterfaceRef;
00117: import anvil.script.LocalVariableType;
00118: import anvil.script.ParameterListDeclaration;
00119: import anvil.script.Scope;
00120: import anvil.script.ModuleEnvelope;
00121: import anvil.script.statements.AssertStatement;
00122: import anvil.script.statements.BreakStatement;
00123: import anvil.script.statements.BlockStatement;
00124: import anvil.script.statements.ImplicitBlockStatement;
00125: import anvil.script.statements.ExplicitBlockStatement;
00126: import anvil.script.statements.CatchStatement;
00127: import anvil.script.statements.ContinueStatement;
00128: import anvil.script.statements.DoStatement;
00129: import anvil.script.statements.Case;
00130: import anvil.script.statements.ClassStatement;
00131: import anvil.script.statements.ConstructorStatement;
00132: import anvil.script.statements.DefinitionStatement;
00133: import anvil.script.statements.FunctionStatement;
00134: import anvil.script.statements.InterfaceStatement;
00135: import anvil.script.statements.InterfaceMethodStatement;
00136: import anvil.script.statements.MethodStatement;
00137: import anvil.script.statements.ModuleStatement;
00138: import anvil.script.statements.EvalStatement;
00139: import anvil.script.statements.ExitStatement;
00140: import anvil.script.statements.FinallyStatement;
00141: import anvil.script.statements.ForeachStatement;
00142: import anvil.script.statements.ForStatement;
00143: import anvil.script.statements.IfStatement;
00144: import anvil.script.statements.PrintStatement;
00145: import anvil.script.statements.ReturnStatement;
00146: import anvil.script.statements.Statement;
00147: import anvil.script.statements.SwitchStatement;
00148: import anvil.script.statements.SynchronizedStatement;
00149: import anvil.script.statements.ThrowStatement;
00150: import anvil.script.statements.TryStatement;
00151: import anvil.script.statements.WhileStatement;
00152: import anvil.script.statements.YieldStatement;
00153: import anvil.script.statements.VariableStatement;
00154: import anvil.script.statements.LocalVariableStatement;
00155: import anvil.script.statements.ConstantVariableStatement;
00156: import anvil.script.statements.NamespaceStatement;
00157: import anvil.script.Grammar;
00158: import anvil.util.Conversions;
00159: import java.util.Enumeration;
00160: import java.util.Stack;
00161: import java.util.ArrayList;
00162: import java.util.List;
00163: import org.apache.oro.text.regex.MalformedPatternException;
00164: import org.apache.oro.text.regex.Pattern;
00165:
00166: /**
00167: * class ParserBase
00168: *
00169: * @author: Jani Lehtimäki
00170: */
00171: public abstract class ParserBase implements ErrorListener,
00172: ParserBaseConstants {
00173:
00174: protected Statement _current = null;
00175: protected NodeStack _nodes = new NodeStack();
00176:
00177: public abstract ModuleEnvelope getEnvelope();
00178:
00179: public abstract Location toLocation(Token t);
00180:
00181: public abstract Location toLocation(int line, int column);
00182:
00183: public abstract void error(Location location, Throwable throwable);
00184:
00185: public abstract void error(Location location, String message);
00186:
00187: public abstract int errors();
00188:
00189: public abstract Enumeration getEvents();
00190:
00191: public abstract void merge(ErrorListener listener);
00192:
00193: public void flowPushChild(Statement stmt) {
00194: //System.out.println("||pushchild:"+_current+" --> "+stmt);
00195: if (_current != null) {
00196: _current.setChildStatement(stmt);
00197: }
00198: _current = stmt;
00199: }
00200:
00201: public void flowPush(Statement stmt) {
00202: //System.out.println("||push:"+_current+" --> "+stmt);
00203: _current = stmt;
00204: }
00205:
00206: public Statement flowPop() {
00207: Statement stmt = _current;
00208: if (stmt != null) {
00209: _current = stmt.getParentStatement();
00210: }
00211: //System.out.println("||pop:"+stmt+" --> "+_current);
00212: return stmt;
00213: }
00214:
00215: public Statement flowPeek() {
00216: return _current;
00217: }
00218:
00219: protected void push(Node node) {
00220: _nodes.push(node);
00221: }
00222:
00223: protected Node pop() throws ParseException {
00224: if (!_nodes.empty()) {
00225: return _nodes.pop();
00226: } else {
00227: throw new ParseException("Parser stack empty");
00228: }
00229: }
00230:
00231: protected Node peek() throws ParseException {
00232: if (!_nodes.empty()) {
00233: return _nodes.peek();
00234: } else {
00235: throw new ParseException("Parser stack empty");
00236: }
00237: }
00238:
00239: public Location getCurrentLocation() {
00240: return toLocation(getToken(1));
00241: }
00242:
00243: protected TryStatement getEnclosingTryBlock() {
00244: Statement stmt = flowPeek();
00245: switch (stmt.typeOf()) {
00246: case Statement.ST_BLOCK:
00247: case Statement.ST_IMPLICIT_BLOCK: {
00248: TryStatement trystmt;
00249: BlockStatement block = (BlockStatement) stmt;
00250: stmt = block.getTail();
00251: if (stmt != null && stmt.typeOf() == Statement.ST_TRY) {
00252: trystmt = (TryStatement) stmt;
00253: if (trystmt.hasFinally()) {
00254: trystmt = block.replaceWithTry();
00255: }
00256: } else {
00257: trystmt = block.replaceWithTry();
00258: }
00259: return trystmt;
00260: }
00261:
00262: default: {
00263: TryStatement trystmt = new TryStatement(stmt, stmt
00264: .getLocation());
00265: stmt.setChildStatement(trystmt);
00266: return trystmt;
00267: }
00268: }
00269: }
00270:
00271: protected void onErrorSkip() {
00272: _nodes.clear();
00273: ParseException e = generateParseException();
00274: error(toLocation(e.currentToken), e.getMessage());
00275: Token t;
00276: do {
00277: t = getNextToken();
00278: } while ((t.kind != SEMICOLON) && (t.kind != END)
00279: && (t.kind != EOF));
00280: }
00281:
00282: /*
00283: * Module starts here
00284: */
00285: final public void Definitions() throws ParseException {
00286: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00287: case IMPORT:
00288: Import();
00289: break;
00290: case NAMESPACE:
00291: Namespace();
00292: break;
00293: case CONST:
00294: ConstantVariable();
00295: break;
00296: case FUNCTION:
00297: case SYNCHRONIZED:
00298: Function();
00299: break;
00300: case INTERFACE:
00301: Interface();
00302: break;
00303: case CLASS:
00304: Class();
00305: break;
00306: case STATIC:
00307: case VAR:
00308: Variable();
00309: break;
00310: default:
00311: jj_la1[0] = jj_gen;
00312: jj_consume_token(-1);
00313: throw new ParseException();
00314: }
00315: }
00316:
00317: final public void Module() throws ParseException {
00318: Token t;
00319: Token n = null;
00320: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00321: case MODULE:
00322: t = jj_consume_token(MODULE);
00323: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00324: case SYMBOL:
00325: n = jj_consume_token(SYMBOL);
00326: break;
00327: default:
00328: jj_la1[1] = jj_gen;
00329: ;
00330: }
00331: String name = (n == null) ? "module" : n.image;
00332: flowPush(new ModuleStatement(getEnvelope(), toLocation(t),
00333: name, t.document));
00334: jj_consume_token(BEGIN);
00335: label_1: while (true) {
00336: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00337: case NAMESPACE:
00338: case IMPORT:
00339: case FUNCTION:
00340: case SYNCHRONIZED:
00341: case STATIC:
00342: case INTERFACE:
00343: case CLASS:
00344: case VAR:
00345: case CONST:
00346: ;
00347: break;
00348: default:
00349: jj_la1[2] = jj_gen;
00350: break label_1;
00351: }
00352: Definitions();
00353: }
00354: jj_consume_token(END);
00355: break;
00356: default:
00357: jj_la1[4] = jj_gen;
00358: flowPush(new ModuleStatement(getEnvelope(), null, "module",
00359: null));
00360: label_2: while (true) {
00361: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00362: case NAMESPACE:
00363: case IMPORT:
00364: case FUNCTION:
00365: case SYNCHRONIZED:
00366: case STATIC:
00367: case INTERFACE:
00368: case CLASS:
00369: case VAR:
00370: case CONST:
00371: ;
00372: break;
00373: default:
00374: jj_la1[3] = jj_gen;
00375: break label_2;
00376: }
00377: Definitions();
00378: }
00379: }
00380: jj_consume_token(0);
00381: }
00382:
00383: final public NamespaceStatement NamespacePart(Location location,
00384: DefinitionStatement scope) throws ParseException {
00385: Token t;
00386: t = jj_consume_token(SYMBOL);
00387: NamespaceStatement namespace;
00388: String name = t.image;
00389: Type declared = scope.lookupDeclaration(name);
00390: if (declared == null) {
00391: namespace = new NamespaceStatement(location, scope,
00392: t.image, t.document);
00393: scope.declare(namespace);
00394: } else if (declared.getType() == Type.NAMESPACE) {
00395: namespace = (NamespaceStatement) declared;
00396: } else {
00397: error(location, "Entity '" + name + "' already declared");
00398: namespace = new NamespaceStatement(location, scope,
00399: t.image, t.document);
00400: }
00401: {
00402: if (true)
00403: return namespace;
00404: }
00405: throw new Error("Missing return statement in function");
00406: }
00407:
00408: final public void Namespace() throws ParseException {
00409: Token t;
00410: Statement stmt = flowPeek();
00411: DefinitionStatement scope = stmt.getScopeStatement();
00412: try {
00413: t = jj_consume_token(NAMESPACE);
00414: Location location = toLocation(t);
00415: scope = NamespacePart(location, scope);
00416: label_3: while (true) {
00417: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00418: case DOT:
00419: ;
00420: break;
00421: default:
00422: jj_la1[5] = jj_gen;
00423: break label_3;
00424: }
00425: jj_consume_token(DOT);
00426: scope = NamespacePart(location, scope);
00427: }
00428: flowPush(scope);
00429: jj_consume_token(BEGIN);
00430: label_4: while (true) {
00431: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00432: case NAMESPACE:
00433: case IMPORT:
00434: case FUNCTION:
00435: case SYNCHRONIZED:
00436: case STATIC:
00437: case INTERFACE:
00438: case CLASS:
00439: case VAR:
00440: case CONST:
00441: ;
00442: break;
00443: default:
00444: jj_la1[6] = jj_gen;
00445: break label_4;
00446: }
00447: Definitions();
00448: }
00449: jj_consume_token(END);
00450: } finally {
00451: _current = stmt;
00452: }
00453: }
00454:
00455: final public Name Name(Name name) throws ParseException {
00456: Token t;
00457: if (name == null) {
00458: name = new Name();
00459: }
00460: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00461: case SYMBOL:
00462: t = jj_consume_token(SYMBOL);
00463: break;
00464: case MODULE:
00465: t = jj_consume_token(MODULE);
00466: break;
00467: default:
00468: jj_la1[7] = jj_gen;
00469: jj_consume_token(-1);
00470: throw new ParseException();
00471: }
00472: name.add(t);
00473: label_5: while (true) {
00474: if (jj_2_1(2)) {
00475: ;
00476: } else {
00477: break label_5;
00478: }
00479: jj_consume_token(DOT);
00480: t = jj_consume_token(SYMBOL);
00481: name.add(t);
00482: }
00483: {
00484: if (true)
00485: return name;
00486: }
00487: throw new Error("Missing return statement in function");
00488: }
00489:
00490: final public Name[] RequestedDeclarations() throws ParseException {
00491: Name name;
00492: Token as = null;
00493: ArrayList decls = new ArrayList();
00494: name = Name(null);
00495: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00496: case DOT:
00497: case AS:
00498: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00499: case AS:
00500: jj_consume_token(AS);
00501: as = jj_consume_token(SYMBOL);
00502: break;
00503: case DOT:
00504: jj_consume_token(DOT);
00505: jj_consume_token(STAR);
00506: name.enableStar();
00507: break;
00508: default:
00509: jj_la1[8] = jj_gen;
00510: jj_consume_token(-1);
00511: throw new ParseException();
00512: }
00513: break;
00514: default:
00515: jj_la1[9] = jj_gen;
00516: ;
00517: }
00518: decls.add(name);
00519: if (as != null) {
00520: name.setAs(as.image);
00521: as = null;
00522: }
00523: label_6: while (true) {
00524: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00525: case COMMA:
00526: ;
00527: break;
00528: default:
00529: jj_la1[10] = jj_gen;
00530: break label_6;
00531: }
00532: jj_consume_token(COMMA);
00533: name = Name(null);
00534: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00535: case DOT:
00536: case AS:
00537: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00538: case AS:
00539: jj_consume_token(AS);
00540: as = jj_consume_token(SYMBOL);
00541: break;
00542: case DOT:
00543: jj_consume_token(DOT);
00544: jj_consume_token(STAR);
00545: name.enableStar();
00546: break;
00547: default:
00548: jj_la1[11] = jj_gen;
00549: jj_consume_token(-1);
00550: throw new ParseException();
00551: }
00552: break;
00553: default:
00554: jj_la1[12] = jj_gen;
00555: ;
00556: }
00557: decls.add(name);
00558: if (as != null) {
00559: name.setAs(as.image);
00560: as = null;
00561: }
00562: }
00563: {
00564: if (true)
00565: return (Name[]) decls.toArray(new Name[decls.size()]);
00566: }
00567: throw new Error("Missing return statement in function");
00568: }
00569:
00570: final public void Import() throws ParseException {
00571: Token t;
00572: Token href;
00573: Token as = null;
00574: Name entity = null;
00575: Name[] decls;
00576: boolean added = false;
00577: DefinitionStatement scope = flowPeek().getDefinitionStatement();
00578: try {
00579: t = jj_consume_token(IMPORT);
00580: Location location = toLocation(t);
00581: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00582: case STRING_LITERAL:
00583: href = jj_consume_token(STRING_LITERAL);
00584: String pathinfo = Conversions
00585: .unescape(href.image, true);
00586: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00587: case AS:
00588: case COLON:
00589: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00590: case AS:
00591: jj_consume_token(AS);
00592: as = jj_consume_token(SYMBOL);
00593: scope.addHrefImport(this , location, pathinfo,
00594: as.image, null, false);
00595: added = true;
00596: break;
00597: case COLON:
00598: jj_consume_token(COLON);
00599: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00600: case MODULE:
00601: case SYMBOL:
00602: decls = RequestedDeclarations();
00603: scope.addHrefImport(this , location,
00604: pathinfo, null, decls, false);
00605: added = true;
00606: break;
00607: case STAR:
00608: jj_consume_token(STAR);
00609: scope.addHrefImport(this , location,
00610: pathinfo, null, null, true);
00611: added = true;
00612: break;
00613: default:
00614: jj_la1[13] = jj_gen;
00615: jj_consume_token(-1);
00616: throw new ParseException();
00617: }
00618: break;
00619: default:
00620: jj_la1[14] = jj_gen;
00621: jj_consume_token(-1);
00622: throw new ParseException();
00623: }
00624: break;
00625: default:
00626: jj_la1[15] = jj_gen;
00627: ;
00628: }
00629: if (!added) {
00630: scope.addHrefImport(this , location, pathinfo, null,
00631: null, false);
00632: }
00633: break;
00634: case MODULE:
00635: case SYMBOL:
00636: entity = Name(null);
00637: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00638: case DOT:
00639: case AS:
00640: case COLON:
00641: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00642: case DOT:
00643: jj_consume_token(DOT);
00644: jj_consume_token(STAR);
00645: scope.addEntityImport(this , location, entity,
00646: null, true);
00647: added = true;
00648: break;
00649: case AS:
00650: jj_consume_token(AS);
00651: as = jj_consume_token(SYMBOL);
00652: entity.setAs(as.image);
00653: scope.addEntityImport(this , location, entity,
00654: null, false);
00655: added = true;
00656: break;
00657: case COLON:
00658: jj_consume_token(COLON);
00659: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00660: case MODULE:
00661: case SYMBOL:
00662: decls = RequestedDeclarations();
00663: scope.addEntityImport(this , location,
00664: entity, decls, false);
00665: added = true;
00666: break;
00667: case STAR:
00668: jj_consume_token(STAR);
00669: scope.addEntityImport(this , location,
00670: entity, null, true);
00671: added = true;
00672: break;
00673: default:
00674: jj_la1[16] = jj_gen;
00675: jj_consume_token(-1);
00676: throw new ParseException();
00677: }
00678: break;
00679: default:
00680: jj_la1[17] = jj_gen;
00681: jj_consume_token(-1);
00682: throw new ParseException();
00683: }
00684: break;
00685: default:
00686: jj_la1[18] = jj_gen;
00687: ;
00688: }
00689: if (!added) {
00690: scope.addEntityImport(this , location, entity, null,
00691: false);
00692: }
00693: break;
00694: default:
00695: jj_la1[19] = jj_gen;
00696: jj_consume_token(-1);
00697: throw new ParseException();
00698: }
00699: jj_consume_token(SEMICOLON);
00700: } catch (ParseException e) {
00701: onErrorSkip();
00702: }
00703: }
00704:
00705: final public void FunctionParameterPart(
00706: ParameterListDeclaration parameters) throws ParseException {
00707: Token t = null;
00708: Token param;
00709: param = jj_consume_token(SYMBOL);
00710: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00711: case ASSIGN:
00712: t = jj_consume_token(ASSIGN);
00713: ExpressionStart();
00714: break;
00715: default:
00716: jj_la1[20] = jj_gen;
00717: ;
00718: }
00719: String symbol = param.image;
00720: Expression defaultexpr = null;
00721: if (t != null) {
00722: defaultexpr = new Expression(pop(), toLocation(t));
00723: } else {
00724: if (parameters.hasDefaultValues()) {
00725: error(toLocation(param),
00726: "Parameters with default values must appear last");
00727: defaultexpr = null;
00728: }
00729: }
00730: if (parameters.isDeclared(symbol)) {
00731: error(toLocation(param), "Entity '" + symbol
00732: + "' is already declared");
00733: }
00734: parameters.add(symbol, defaultexpr);
00735: }
00736:
00737: final public void FunctionParameterRest(
00738: ParameterListDeclaration parameters) throws ParseException {
00739: Token param;
00740: param = jj_consume_token(SYMBOL);
00741: String symbol = param.image;
00742: if (parameters.isDeclared(symbol)) {
00743: error(toLocation(param), "Entity '" + symbol
00744: + "' is already declared");
00745: } else {
00746: parameters.add(CompilableFunction.PARAMETER_REST, symbol,
00747: Any.EMPTY_TUPLE, null);
00748: }
00749: }
00750:
00751: final public void TerminalFunctionParameterList(
00752: ParameterListDeclaration parameters) throws ParseException {
00753: FunctionParameterList(parameters);
00754: jj_consume_token(0);
00755: }
00756:
00757: final public void FunctionParameterList(
00758: ParameterListDeclaration parameters) throws ParseException {
00759: parameters.open();
00760: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00761: case SYMBOL:
00762: case RANGE:
00763: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00764: case SYMBOL:
00765: FunctionParameterPart(parameters);
00766: label_7: while (true) {
00767: if (jj_2_2(2)) {
00768: ;
00769: } else {
00770: break label_7;
00771: }
00772: jj_consume_token(COMMA);
00773: FunctionParameterPart(parameters);
00774: }
00775: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00776: case COMMA:
00777: jj_consume_token(COMMA);
00778: jj_consume_token(RANGE);
00779: FunctionParameterRest(parameters);
00780: break;
00781: default:
00782: jj_la1[21] = jj_gen;
00783: ;
00784: }
00785: break;
00786: case RANGE:
00787: jj_consume_token(RANGE);
00788: FunctionParameterRest(parameters);
00789: break;
00790: default:
00791: jj_la1[22] = jj_gen;
00792: jj_consume_token(-1);
00793: throw new ParseException();
00794: }
00795: break;
00796: default:
00797: jj_la1[23] = jj_gen;
00798: ;
00799: }
00800: parameters.close();
00801: }
00802:
00803: final public void InterfaceMethod() throws ParseException {
00804: Token t, s;
00805: ParameterListDeclaration parameters = new ParameterListDeclaration();
00806: t = jj_consume_token(FUNCTION);
00807: s = jj_consume_token(SYMBOL);
00808: jj_consume_token(OPEN);
00809: FunctionParameterList(parameters);
00810: jj_consume_token(CLOSE);
00811: jj_consume_token(SEMICOLON);
00812: Location location = toLocation(t);
00813: String name = s.image;
00814: InterfaceStatement intrface = flowPeek()
00815: .getInterfaceStatement();
00816: InterfaceMethodStatement method = new InterfaceMethodStatement(
00817: location, intrface, name, t.document, parameters);
00818: if (intrface.lookupDeclaration(name) == null) {
00819: intrface.declare(method);
00820: } else {
00821: error(location, "Entity '" + name + "' is already declared");
00822: }
00823: }
00824:
00825: final public void ConstructorInvoke() throws ParseException {
00826: Token t;
00827: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00828: case SUPER:
00829: t = jj_consume_token(SUPER);
00830: jj_consume_token(OPEN);
00831: ArgumentList();
00832: jj_consume_token(CLOSE);
00833: jj_consume_token(SEMICOLON);
00834: Location location = toLocation(t);
00835: flowPushChild(new EvalStatement(flowPeek(), location,
00836: new Expression(new LinkNode(flowPeek(), location,
00837: new Name().add(t), (Parent) pop(),
00838: LinkNode.SUPER), location)));
00839: flowPop();
00840: break;
00841: default:
00842: jj_la1[24] = jj_gen;
00843: ;
00844: }
00845: }
00846:
00847: final public void Function() throws ParseException {
00848: Token r = null;
00849: Token t;
00850: Token s;
00851: ParameterListDeclaration parameters = new ParameterListDeclaration();
00852: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00853: case SYNCHRONIZED:
00854: r = jj_consume_token(SYNCHRONIZED);
00855: break;
00856: default:
00857: jj_la1[25] = jj_gen;
00858: ;
00859: }
00860: t = jj_consume_token(FUNCTION);
00861: s = jj_consume_token(SYMBOL);
00862: jj_consume_token(OPEN);
00863: FunctionParameterList(parameters);
00864: jj_consume_token(CLOSE);
00865: boolean is_synchronized = (r != null);
00866: String name = s.image;
00867: String document = (r != null) ? r.document : t.document;
00868:
00869: DefinitionStatement target = flowPeek()
00870: .getDefinitionStatement();
00871: DefinitionStatement parent = flowPeek().getScopeStatement();
00872: FunctionStatement context = flowPeek().getFunctionStatement();
00873:
00874: FunctionStatement function = new FunctionStatement(
00875: toLocation(t), parent, context, is_synchronized, name,
00876: document, parameters);
00877: function.setParentStatement(flowPeek());
00878: if (target.lookupDeclaration(name) == null) {
00879: parent.declare(function);
00880: if (context != null) {
00881: context.declare(name, function);
00882: }
00883: } else {
00884: error(toLocation(t), "Entity '" + name
00885: + "' is already declared");
00886: }
00887: flowPush(function);
00888: flowPush(function.getChildStatement());
00889: jj_consume_token(BEGIN);
00890: label_8: while (true) {
00891: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00892: case MODULE:
00893: case SYMBOL:
00894: case BEGIN:
00895: case DOT:
00896: case STAR:
00897: case IMPORT:
00898: case STRING_LITERAL:
00899: case SEMICOLON:
00900: case RANGE:
00901: case FUNCTION:
00902: case OPEN:
00903: case SUPER:
00904: case SYNCHRONIZED:
00905: case STATIC:
00906: case CLASS:
00907: case VAR:
00908: case IF:
00909: case WHILE:
00910: case TRY:
00911: case CATCH:
00912: case FINALLY:
00913: case THROW:
00914: case PRINT:
00915: case HOOK:
00916: case PRINTLN:
00917: case PRINTBR:
00918: case SWITCH:
00919: case FOR:
00920: case DO:
00921: case FOREACH:
00922: case BREAK:
00923: case CONTINUE:
00924: case EXIT:
00925: case RETURN:
00926: case YIELD:
00927: case ASSERT:
00928: case ET:
00929: case NEGATION:
00930: case PLUS:
00931: case MINUS:
00932: case MINUSMINUS:
00933: case PLUSPLUS:
00934: case COPYOF:
00935: case CLONEOF:
00936: case TYPEOF:
00937: case SIZEOF:
00938: case CLASSOF:
00939: case BOOLEAN:
00940: case INT:
00941: case FLOAT:
00942: case STRING:
00943: case DEFINED:
00944: case UNDEFINED:
00945: case NULL:
00946: case OPEN_BRACKET:
00947: case CARET:
00948: case DELETE:
00949: case BEGIN_LIST:
00950: case NEW:
00951: case THIS:
00952: case INTEGER_LITERAL:
00953: case FLOATING_POINT_LITERAL:
00954: case INF:
00955: case FALSE:
00956: case TRUE:
00957: case PATTERN:
00958: ;
00959: break;
00960: default:
00961: jj_la1[26] = jj_gen;
00962: break label_8;
00963: }
00964: if (jj_2_3(2)) {
00965: Statement();
00966: } else {
00967: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00968: case FUNCTION:
00969: case SYNCHRONIZED:
00970: Function();
00971: break;
00972: case IMPORT:
00973: Import();
00974: break;
00975: default:
00976: jj_la1[27] = jj_gen;
00977: jj_consume_token(-1);
00978: throw new ParseException();
00979: }
00980: }
00981: }
00982: jj_consume_token(END);
00983: flowPop();
00984: flowPop();
00985: }
00986:
00987: final public void Method() throws ParseException {
00988: boolean is_synchronized = false;
00989: boolean is_static = false;
00990: Token t;
00991: Token s;
00992: ParameterListDeclaration parameters = new ParameterListDeclaration();
00993: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00994: case SYNCHRONIZED:
00995: t = jj_consume_token(SYNCHRONIZED);
00996: is_synchronized = true;
00997: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00998: case STATIC:
00999: jj_consume_token(STATIC);
01000: is_static = true;
01001: break;
01002: default:
01003: jj_la1[28] = jj_gen;
01004: ;
01005: }
01006: jj_consume_token(FUNCTION);
01007: break;
01008: case STATIC:
01009: t = jj_consume_token(STATIC);
01010: is_static = true;
01011: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01012: case SYNCHRONIZED:
01013: jj_consume_token(SYNCHRONIZED);
01014: is_synchronized = true;
01015: break;
01016: default:
01017: jj_la1[29] = jj_gen;
01018: ;
01019: }
01020: jj_consume_token(FUNCTION);
01021: break;
01022: case FUNCTION:
01023: t = jj_consume_token(FUNCTION);
01024: break;
01025: default:
01026: jj_la1[30] = jj_gen;
01027: jj_consume_token(-1);
01028: throw new ParseException();
01029: }
01030: s = jj_consume_token(SYMBOL);
01031: jj_consume_token(OPEN);
01032: FunctionParameterList(parameters);
01033: jj_consume_token(CLOSE);
01034: boolean is_constructor = false;
01035: Location location = toLocation(t);
01036: String document = t.document;
01037: String name = s.image;
01038:
01039: DefinitionStatement target = flowPeek()
01040: .getDefinitionStatement();
01041: ClassStatement parent = flowPeek().getClassStatement();
01042: FunctionStatement context = flowPeek().getFunctionStatement();
01043:
01044: if (context != null) {
01045: if (context.getType() == Type.FUNCTION) {
01046: is_static = true;
01047: }
01048: }
01049: if (is_static) {
01050: if (name.equals(parent.getName())) {
01051: error(location,
01052: "Static methods may not used as constructors");
01053: }
01054: FunctionStatement function = new FunctionStatement(
01055: location, parent, context, is_synchronized, name,
01056: document, parameters);
01057: function.setParentStatement(flowPeek());
01058: if (target.lookupDeclaration(name) == null) {
01059: parent.declare(function);
01060: if (context != null) {
01061: context.declare(name, function);
01062: }
01063: } else {
01064: error(location, "Entity '" + name
01065: + "' is already declared");
01066: }
01067: flowPush(function);
01068: flowPush(function.getChildStatement());
01069:
01070: } else {
01071: MethodStatement method;
01072: if ((context == null) && name.equals(parent.getName())) {
01073: is_constructor = true;
01074: method = new ConstructorStatement(location, parent,
01075: is_synchronized, name, document, parameters);
01076: if (parent.getConstructor() != null) {
01077: error(location,
01078: "Constructor is already declared for class '"
01079: + parent + "'");
01080: }
01081: } else {
01082: method = new MethodStatement(location, parent, context,
01083: is_synchronized, name, document, parameters);
01084: }
01085: method.setParentStatement(flowPeek());
01086: if (target.lookupLocalDeclaration(name) == null) {
01087: parent.declare(method);
01088: if (context != null) {
01089: context.declare(name, method);
01090: }
01091: } else {
01092: error(location, "Entity '" + name
01093: + "' is already declared");
01094: }
01095: flowPush(method);
01096: flowPush(method.getChildStatement());
01097:
01098: }
01099: jj_consume_token(BEGIN);
01100: if (is_constructor) {
01101: ConstructorInvoke();
01102: }
01103: label_9: while (true) {
01104: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01105: case MODULE:
01106: case SYMBOL:
01107: case BEGIN:
01108: case DOT:
01109: case STAR:
01110: case IMPORT:
01111: case STRING_LITERAL:
01112: case SEMICOLON:
01113: case RANGE:
01114: case FUNCTION:
01115: case OPEN:
01116: case SUPER:
01117: case SYNCHRONIZED:
01118: case STATIC:
01119: case CLASS:
01120: case VAR:
01121: case IF:
01122: case WHILE:
01123: case TRY:
01124: case CATCH:
01125: case FINALLY:
01126: case THROW:
01127: case PRINT:
01128: case HOOK:
01129: case PRINTLN:
01130: case PRINTBR:
01131: case SWITCH:
01132: case FOR:
01133: case DO:
01134: case FOREACH:
01135: case BREAK:
01136: case CONTINUE:
01137: case EXIT:
01138: case RETURN:
01139: case YIELD:
01140: case ASSERT:
01141: case ET:
01142: case NEGATION:
01143: case PLUS:
01144: case MINUS:
01145: case MINUSMINUS:
01146: case PLUSPLUS:
01147: case COPYOF:
01148: case CLONEOF:
01149: case TYPEOF:
01150: case SIZEOF:
01151: case CLASSOF:
01152: case BOOLEAN:
01153: case INT:
01154: case FLOAT:
01155: case STRING:
01156: case DEFINED:
01157: case UNDEFINED:
01158: case NULL:
01159: case OPEN_BRACKET:
01160: case CARET:
01161: case DELETE:
01162: case BEGIN_LIST:
01163: case NEW:
01164: case THIS:
01165: case INTEGER_LITERAL:
01166: case FLOATING_POINT_LITERAL:
01167: case INF:
01168: case FALSE:
01169: case TRUE:
01170: case PATTERN:
01171: ;
01172: break;
01173: default:
01174: jj_la1[31] = jj_gen;
01175: break label_9;
01176: }
01177: if (jj_2_4(2)) {
01178: Statement();
01179: } else {
01180: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01181: case FUNCTION:
01182: case SYNCHRONIZED:
01183: case STATIC:
01184: Method();
01185: break;
01186: case IMPORT:
01187: Import();
01188: break;
01189: default:
01190: jj_la1[32] = jj_gen;
01191: jj_consume_token(-1);
01192: throw new ParseException();
01193: }
01194: }
01195: }
01196: jj_consume_token(END);
01197: flowPop();
01198: flowPop();
01199: }
01200:
01201: final public void InlineFunction() throws ParseException {
01202: Token t;
01203: ParameterListDeclaration parameters = new ParameterListDeclaration();
01204: jj_consume_token(BEGIN);
01205: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01206: case PIPE:
01207: t = jj_consume_token(PIPE);
01208: FunctionParameterList(parameters);
01209: jj_consume_token(PIPE);
01210: break;
01211: case BOOLEAN_OR:
01212: t = jj_consume_token(BOOLEAN_OR);
01213: parameters.open();
01214: parameters.close();
01215: break;
01216: default:
01217: jj_la1[33] = jj_gen;
01218: jj_consume_token(-1);
01219: throw new ParseException();
01220: }
01221: Statement stmt = flowPeek();
01222: DefinitionStatement parent = stmt.getScopeStatement();
01223: FunctionStatement context = stmt.getFunctionStatement();
01224: FunctionStatement function;
01225: String name = "inline$" + parent.getNextInlined();
01226: if (parent.typeOf() == Statement.ST_CLASS) {
01227: function = new MethodStatement(toLocation(t), parent,
01228: context, false, name, null, parameters);
01229: } else {
01230: function = new FunctionStatement(toLocation(t), parent,
01231: context, false, name, null, parameters);
01232: }
01233: function.setParentStatement(flowPeek());
01234: parent.declare(function);
01235: flowPush(function);
01236: flowPush(function.getChildStatement());
01237: push(new InlinedFunctionNode(context, function));
01238: label_10: while (true) {
01239: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01240: case MODULE:
01241: case SYMBOL:
01242: case BEGIN:
01243: case DOT:
01244: case STAR:
01245: case IMPORT:
01246: case STRING_LITERAL:
01247: case SEMICOLON:
01248: case RANGE:
01249: case FUNCTION:
01250: case OPEN:
01251: case SUPER:
01252: case SYNCHRONIZED:
01253: case STATIC:
01254: case CLASS:
01255: case VAR:
01256: case IF:
01257: case WHILE:
01258: case TRY:
01259: case CATCH:
01260: case FINALLY:
01261: case THROW:
01262: case PRINT:
01263: case HOOK:
01264: case PRINTLN:
01265: case PRINTBR:
01266: case SWITCH:
01267: case FOR:
01268: case DO:
01269: case FOREACH:
01270: case BREAK:
01271: case CONTINUE:
01272: case EXIT:
01273: case RETURN:
01274: case YIELD:
01275: case ASSERT:
01276: case ET:
01277: case NEGATION:
01278: case PLUS:
01279: case MINUS:
01280: case MINUSMINUS:
01281: case PLUSPLUS:
01282: case COPYOF:
01283: case CLONEOF:
01284: case TYPEOF:
01285: case SIZEOF:
01286: case CLASSOF:
01287: case BOOLEAN:
01288: case INT:
01289: case FLOAT:
01290: case STRING:
01291: case DEFINED:
01292: case UNDEFINED:
01293: case NULL:
01294: case OPEN_BRACKET:
01295: case CARET:
01296: case DELETE:
01297: case BEGIN_LIST:
01298: case NEW:
01299: case THIS:
01300: case INTEGER_LITERAL:
01301: case FLOATING_POINT_LITERAL:
01302: case INF:
01303: case FALSE:
01304: case TRUE:
01305: case PATTERN:
01306: ;
01307: break;
01308: default:
01309: jj_la1[34] = jj_gen;
01310: break label_10;
01311: }
01312: Statement();
01313: }
01314: jj_consume_token(END);
01315: flowPop();
01316: flowPop();
01317: }
01318:
01319: final public LinkNode EntityReference(Location location)
01320: throws ParseException {
01321: Name name;
01322: name = Name(null);
01323: {
01324: if (true)
01325: return new LinkNode(flowPeek(), location, name);
01326: }
01327: throw new Error("Missing return statement in function");
01328: }
01329:
01330: final public void InterfaceReference(Location location,
01331: List interfaces) throws ParseException {
01332: LinkNode link;
01333: link = EntityReference(location);
01334: interfaces.add(new InterfaceRef(link));
01335: }
01336:
01337: final public InterfaceRef[] Interfaces(Location location)
01338: throws ParseException {
01339: ArrayList interfaces = new ArrayList();
01340: InterfaceReference(location, interfaces);
01341: label_11: while (true) {
01342: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01343: case COMMA:
01344: ;
01345: break;
01346: default:
01347: jj_la1[35] = jj_gen;
01348: break label_11;
01349: }
01350: jj_consume_token(COMMA);
01351: InterfaceReference(location, interfaces);
01352: }
01353: {
01354: if (true)
01355: return (InterfaceRef[]) interfaces
01356: .toArray(new InterfaceRef[interfaces.size()]);
01357: }
01358: throw new Error("Missing return statement in function");
01359: }
01360:
01361: final public void Interface() throws ParseException {
01362: Token t;
01363: Token s;
01364: InterfaceRef[] interfaces = new InterfaceRef[0];
01365: t = jj_consume_token(INTERFACE);
01366: Location location = toLocation(t);
01367: s = jj_consume_token(SYMBOL);
01368: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01369: case EXTENDS:
01370: jj_consume_token(EXTENDS);
01371: interfaces = Interfaces(location);
01372: break;
01373: default:
01374: jj_la1[36] = jj_gen;
01375: ;
01376: }
01377: jj_consume_token(BEGIN);
01378: String name = s.image;
01379: DefinitionStatement parent = flowPeek().getScopeStatement();
01380: InterfaceStatement decl = new InterfaceStatement(location,
01381: parent, name, t.document, interfaces);
01382: if (parent.lookupDeclaration(name) == null) {
01383: parent.declare(decl);
01384: } else {
01385: error(location, "Entity '" + name + "' is already declared");
01386: }
01387: flowPush(decl);
01388: label_12: while (true) {
01389: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01390: case IMPORT:
01391: case FUNCTION:
01392: case STATIC:
01393: case INTERFACE:
01394: case CONST:
01395: ;
01396: break;
01397: default:
01398: jj_la1[37] = jj_gen;
01399: break label_12;
01400: }
01401: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01402: case IMPORT:
01403: Import();
01404: break;
01405: case CONST:
01406: ConstantVariable();
01407: break;
01408: case FUNCTION:
01409: InterfaceMethod();
01410: break;
01411: case STATIC:
01412: jj_consume_token(STATIC);
01413: Function();
01414: break;
01415: case INTERFACE:
01416: Interface();
01417: break;
01418: default:
01419: jj_la1[38] = jj_gen;
01420: jj_consume_token(-1);
01421: throw new ParseException();
01422: }
01423: }
01424: jj_consume_token(END);
01425: flowPop();
01426: }
01427:
01428: final public void Class() throws ParseException {
01429: Token t;
01430: Token s;
01431: ClassRef base = null;
01432: InterfaceRef[] interfaces = new InterfaceRef[0];
01433: LinkNode link;
01434: t = jj_consume_token(CLASS);
01435: s = jj_consume_token(SYMBOL);
01436: Location location = toLocation(t);
01437: String name = s.image;
01438: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01439: case EXTENDS:
01440: jj_consume_token(EXTENDS);
01441: link = EntityReference(location);
01442: base = new ClassRef(link);
01443: break;
01444: default:
01445: jj_la1[39] = jj_gen;
01446: ;
01447: }
01448: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01449: case IMPLEMENTS:
01450: jj_consume_token(IMPLEMENTS);
01451: interfaces = Interfaces(location);
01452: break;
01453: default:
01454: jj_la1[40] = jj_gen;
01455: ;
01456: }
01457: jj_consume_token(BEGIN);
01458: DefinitionStatement parent = flowPeek()
01459: .getDefinitionStatement();
01460: ClassStatement classtype = new ClassStatement(location, parent,
01461: name, t.document, base, interfaces);
01462: if (parent.lookupDeclaration(name) == null
01463: && !parent.isEntityReserved(name)) {
01464: parent.declare(classtype);
01465: } else {
01466: error(location, "Entity '" + name + "' is already declared");
01467: }
01468: flowPush(classtype);
01469: label_13: while (true) {
01470: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01471: case IMPORT:
01472: case FUNCTION:
01473: case SYNCHRONIZED:
01474: case STATIC:
01475: case CLASS:
01476: case VAR:
01477: case CONST:
01478: ;
01479: break;
01480: default:
01481: jj_la1[41] = jj_gen;
01482: break label_13;
01483: }
01484: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01485: case IMPORT:
01486: Import();
01487: break;
01488: case CONST:
01489: ConstantVariable();
01490: break;
01491: case CLASS:
01492: Class();
01493: break;
01494: default:
01495: jj_la1[42] = jj_gen;
01496: if (jj_2_5(2)) {
01497: Variable();
01498: } else {
01499: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01500: case FUNCTION:
01501: case SYNCHRONIZED:
01502: case STATIC:
01503: Method();
01504: break;
01505: default:
01506: jj_la1[43] = jj_gen;
01507: jj_consume_token(-1);
01508: throw new ParseException();
01509: }
01510: }
01511: }
01512: }
01513: jj_consume_token(END);
01514: classtype.finish();
01515: flowPop();
01516: }
01517:
01518: final public void Variable() throws ParseException {
01519: Token t;
01520: String document = null;
01521: boolean statik = false;
01522: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01523: case STATIC:
01524: t = jj_consume_token(STATIC);
01525: document = t.document;
01526: statik = true;
01527: break;
01528: default:
01529: jj_la1[44] = jj_gen;
01530: ;
01531: }
01532: t = jj_consume_token(VAR);
01533: if (document == null) {
01534: document = t.document;
01535: }
01536: VariableTypePart(statik, document);
01537: label_14: while (true) {
01538: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01539: case COMMA:
01540: ;
01541: break;
01542: default:
01543: jj_la1[45] = jj_gen;
01544: break label_14;
01545: }
01546: jj_consume_token(COMMA);
01547: VariableTypePart(statik, document);
01548: }
01549: jj_consume_token(SEMICOLON);
01550: }
01551:
01552: final public void VariableTypePart(boolean statik, String document)
01553: throws ParseException {
01554: Token symbol;
01555: Expression expr = null;
01556: symbol = jj_consume_token(SYMBOL);
01557: Location location = toLocation(symbol);
01558: String name = symbol.image;
01559: DefinitionStatement target = flowPeek()
01560: .getDefinitionStatement();
01561: VariableStatement var = null;
01562: if (target.lookupDeclaration(name) == null
01563: && !target.isEntityReserved(name)) {
01564: var = target
01565: .declare(location, name, expr, document, statik);
01566: } else {
01567: error(location, "Entity '" + name + "' is already declared");
01568: }
01569: if (var != null) {
01570: flowPush(var);
01571: }
01572: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01573: case ASSIGN:
01574: jj_consume_token(ASSIGN);
01575: ValueExpression();
01576: expr = (Expression) pop();
01577: break;
01578: default:
01579: jj_la1[46] = jj_gen;
01580: ;
01581: }
01582: if (var != null) {
01583: var.setExpression(expr);
01584: flowPop();
01585: }
01586: }
01587:
01588: final public void ConstantVariable() throws ParseException {
01589: Token keyword;
01590: keyword = jj_consume_token(CONST);
01591: ConstantVariablePart(keyword);
01592: label_15: while (true) {
01593: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01594: case COMMA:
01595: ;
01596: break;
01597: default:
01598: jj_la1[47] = jj_gen;
01599: break label_15;
01600: }
01601: jj_consume_token(COMMA);
01602: ConstantVariablePart(keyword);
01603: }
01604: jj_consume_token(SEMICOLON);
01605: }
01606:
01607: final public void ConstantVariablePart(Token keyword)
01608: throws ParseException {
01609: Token symbol;
01610: symbol = jj_consume_token(SYMBOL);
01611: jj_consume_token(ASSIGN);
01612: Location location = toLocation(symbol);
01613: String name = symbol.image;
01614: DefinitionStatement target = flowPeek()
01615: .getDefinitionStatement();
01616: ConstantVariableStatement constant = new ConstantVariableStatement(
01617: location, target, name, null, keyword.document);
01618: if (target.lookupDeclaration(name) == null
01619: && !target.isEntityReserved(name)) {
01620: target.declare(constant);
01621: } else {
01622: error(location, "Entity '" + name + "' is already declared");
01623: }
01624: flowPush(constant);
01625: ValueExpression();
01626: constant.setExpression((Expression) pop());
01627: flowPop();
01628: }
01629:
01630: /*
01631: * Statement syntax follows.
01632: */
01633: final public void StandaloneStatements() throws ParseException {
01634: label_16: while (true) {
01635: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01636: case MODULE:
01637: case SYMBOL:
01638: case BEGIN:
01639: case DOT:
01640: case STAR:
01641: case IMPORT:
01642: case STRING_LITERAL:
01643: case SEMICOLON:
01644: case RANGE:
01645: case FUNCTION:
01646: case OPEN:
01647: case SUPER:
01648: case SYNCHRONIZED:
01649: case STATIC:
01650: case CLASS:
01651: case VAR:
01652: case IF:
01653: case WHILE:
01654: case TRY:
01655: case CATCH:
01656: case FINALLY:
01657: case THROW:
01658: case PRINT:
01659: case HOOK:
01660: case PRINTLN:
01661: case PRINTBR:
01662: case SWITCH:
01663: case FOR:
01664: case DO:
01665: case FOREACH:
01666: case BREAK:
01667: case CONTINUE:
01668: case EXIT:
01669: case RETURN:
01670: case YIELD:
01671: case ASSERT:
01672: case ET:
01673: case NEGATION:
01674: case PLUS:
01675: case MINUS:
01676: case MINUSMINUS:
01677: case PLUSPLUS:
01678: case COPYOF:
01679: case CLONEOF:
01680: case TYPEOF:
01681: case SIZEOF:
01682: case CLASSOF:
01683: case BOOLEAN:
01684: case INT:
01685: case FLOAT:
01686: case STRING:
01687: case DEFINED:
01688: case UNDEFINED:
01689: case NULL:
01690: case OPEN_BRACKET:
01691: case CARET:
01692: case DELETE:
01693: case BEGIN_LIST:
01694: case NEW:
01695: case THIS:
01696: case INTEGER_LITERAL:
01697: case FLOATING_POINT_LITERAL:
01698: case INF:
01699: case FALSE:
01700: case TRUE:
01701: case PATTERN:
01702: ;
01703: break;
01704: default:
01705: jj_la1[48] = jj_gen;
01706: break label_16;
01707: }
01708: Statement();
01709: }
01710: jj_consume_token(0);
01711: }
01712:
01713: final public void Statement() throws ParseException {
01714: String label = null;
01715: Statement current = _current;
01716: try {
01717: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01718: case SEMICOLON:
01719: EmptyStatement();
01720: break;
01721: case PRINT:
01722: case HOOK:
01723: case PRINTLN:
01724: case PRINTBR:
01725: PrintStatement();
01726: break;
01727: case BREAK:
01728: BreakStatement();
01729: break;
01730: case CONTINUE:
01731: ContinueStatement();
01732: break;
01733: case RETURN:
01734: ReturnStatement();
01735: break;
01736: case YIELD:
01737: YieldStatement();
01738: break;
01739: case EXIT:
01740: ExitStatement();
01741: break;
01742: case ASSERT:
01743: AssertStatement();
01744: break;
01745: case TRY:
01746: TryStatement();
01747: break;
01748: case THROW:
01749: ThrowStatement();
01750: break;
01751: case CATCH:
01752: CatchStatement(null);
01753: break;
01754: case FINALLY:
01755: FinallyStatement(null);
01756: break;
01757: case SYNCHRONIZED:
01758: SynchronizedStatement();
01759: break;
01760: case IF:
01761: IfStatement();
01762: break;
01763: case WHILE:
01764: WhileStatement(null);
01765: break;
01766: case FOR:
01767: ForStatement(null);
01768: break;
01769: case DO:
01770: DoStatement(null);
01771: break;
01772: case FOREACH:
01773: ForeachStatement(null);
01774: break;
01775: case SWITCH:
01776: SwitchStatement(null);
01777: break;
01778: default:
01779: jj_la1[50] = jj_gen;
01780: if (jj_2_6(2)) {
01781: label = StatementLabel();
01782: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01783: case WHILE:
01784: WhileStatement(label);
01785: break;
01786: case FOR:
01787: ForStatement(label);
01788: break;
01789: case DO:
01790: DoStatement(label);
01791: break;
01792: case FOREACH:
01793: ForeachStatement(label);
01794: break;
01795: case SWITCH:
01796: SwitchStatement(label);
01797: break;
01798: case BEGIN:
01799: BlockStatement(label);
01800: break;
01801: default:
01802: jj_la1[49] = jj_gen;
01803: jj_consume_token(-1);
01804: throw new ParseException();
01805: }
01806: } else if (jj_2_7(2)) {
01807: BlockStatement(null);
01808: } else {
01809: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01810: case MODULE:
01811: case SYMBOL:
01812: case BEGIN:
01813: case DOT:
01814: case STAR:
01815: case IMPORT:
01816: case STRING_LITERAL:
01817: case RANGE:
01818: case FUNCTION:
01819: case OPEN:
01820: case SUPER:
01821: case STATIC:
01822: case CLASS:
01823: case VAR:
01824: case ET:
01825: case NEGATION:
01826: case PLUS:
01827: case MINUS:
01828: case MINUSMINUS:
01829: case PLUSPLUS:
01830: case COPYOF:
01831: case CLONEOF:
01832: case TYPEOF:
01833: case SIZEOF:
01834: case CLASSOF:
01835: case BOOLEAN:
01836: case INT:
01837: case FLOAT:
01838: case STRING:
01839: case DEFINED:
01840: case UNDEFINED:
01841: case NULL:
01842: case OPEN_BRACKET:
01843: case CARET:
01844: case DELETE:
01845: case BEGIN_LIST:
01846: case NEW:
01847: case THIS:
01848: case INTEGER_LITERAL:
01849: case FLOATING_POINT_LITERAL:
01850: case INF:
01851: case FALSE:
01852: case TRUE:
01853: case PATTERN:
01854: ExpressionStatement();
01855: break;
01856: default:
01857: jj_la1[51] = jj_gen;
01858: jj_consume_token(-1);
01859: throw new ParseException();
01860: }
01861: }
01862: }
01863: } catch (ParseException e) {
01864: onErrorSkip();
01865: _current = current;
01866: }
01867: }
01868:
01869: final public void StatementModifier(Statement stmt)
01870: throws ParseException {
01871: Token t;
01872: Expression expr;
01873: IfStatement ifStmt;
01874: Statement context = flowPeek();
01875: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01876: case IF:
01877: t = jj_consume_token(IF);
01878: Expression();
01879: jj_consume_token(SEMICOLON);
01880: ifStmt = new IfStatement(context, toLocation(t),
01881: (Expression) pop());
01882: ifStmt.setChildStatement(stmt);
01883: stmt.setParentStatement(ifStmt);
01884: context.setChildStatement(ifStmt);
01885: break;
01886: case WHILE:
01887: t = jj_consume_token(WHILE);
01888: Expression();
01889: jj_consume_token(SEMICOLON);
01890: WhileStatement whileStmt = new WhileStatement(context,
01891: toLocation(t), (Expression) pop(), null);
01892: whileStmt.setChildStatement(stmt);
01893: stmt.setParentStatement(whileStmt);
01894: context.setChildStatement(whileStmt);
01895: break;
01896: case SEMICOLON:
01897: t = jj_consume_token(SEMICOLON);
01898: context.setChildStatement(stmt);
01899: break;
01900: default:
01901: jj_la1[52] = jj_gen;
01902: jj_consume_token(-1);
01903: throw new ParseException();
01904: }
01905: }
01906:
01907: final public void BlockStatement(String label)
01908: throws ParseException {
01909: Token t;
01910: t = jj_consume_token(BEGIN);
01911: Statement context = flowPeek();
01912: if (label != null) {
01913: flowPushChild(new ExplicitBlockStatement(context,
01914: toLocation(t), label));
01915: } else {
01916: flowPushChild(new ImplicitBlockStatement(context,
01917: toLocation(t)));
01918: }
01919: label_17: while (true) {
01920: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01921: case MODULE:
01922: case SYMBOL:
01923: case BEGIN:
01924: case DOT:
01925: case STAR:
01926: case IMPORT:
01927: case STRING_LITERAL:
01928: case SEMICOLON:
01929: case RANGE:
01930: case FUNCTION:
01931: case OPEN:
01932: case SUPER:
01933: case SYNCHRONIZED:
01934: case STATIC:
01935: case CLASS:
01936: case VAR:
01937: case IF:
01938: case WHILE:
01939: case TRY:
01940: case CATCH:
01941: case FINALLY:
01942: case THROW:
01943: case PRINT:
01944: case HOOK:
01945: case PRINTLN:
01946: case PRINTBR:
01947: case SWITCH:
01948: case FOR:
01949: case DO:
01950: case FOREACH:
01951: case BREAK:
01952: case CONTINUE:
01953: case EXIT:
01954: case RETURN:
01955: case YIELD:
01956: case ASSERT:
01957: case ET:
01958: case NEGATION:
01959: case PLUS:
01960: case MINUS:
01961: case MINUSMINUS:
01962: case PLUSPLUS:
01963: case COPYOF:
01964: case CLONEOF:
01965: case TYPEOF:
01966: case SIZEOF:
01967: case CLASSOF:
01968: case BOOLEAN:
01969: case INT:
01970: case FLOAT:
01971: case STRING:
01972: case DEFINED:
01973: case UNDEFINED:
01974: case NULL:
01975: case OPEN_BRACKET:
01976: case CARET:
01977: case DELETE:
01978: case BEGIN_LIST:
01979: case NEW:
01980: case THIS:
01981: case INTEGER_LITERAL:
01982: case FLOATING_POINT_LITERAL:
01983: case INF:
01984: case FALSE:
01985: case TRUE:
01986: case PATTERN:
01987: ;
01988: break;
01989: default:
01990: jj_la1[53] = jj_gen;
01991: break label_17;
01992: }
01993: Statement();
01994: }
01995: jj_consume_token(END);
01996: flowPop();
01997: }
01998:
01999: final public void TryStatement() throws ParseException {
02000: Token t;
02001: t = jj_consume_token(TRY);
02002: TryStatement trystmt = new TryStatement(flowPeek(),
02003: toLocation(t));
02004: flowPushChild(trystmt);
02005: Statement();
02006: label_18: while (true) {
02007: if (jj_2_8(2147483647)) {
02008: ;
02009: } else {
02010: break label_18;
02011: }
02012: CatchStatement(trystmt);
02013: }
02014: if (jj_2_9(2147483647)) {
02015: FinallyStatement(trystmt);
02016: } else {
02017: ;
02018: }
02019: flowPop();
02020: }
02021:
02022: final public void ThrowStatement() throws ParseException {
02023: Token t;
02024: Statement stmt;
02025: t = jj_consume_token(THROW);
02026: ListExpression();
02027: stmt = new ThrowStatement(flowPeek(), toLocation(t),
02028: (Expression) pop());
02029: StatementModifier(stmt);
02030: }
02031:
02032: final public void CatchStatement(TryStatement trystmt)
02033: throws ParseException {
02034: Token t;
02035: Token param;
02036: int count = 0;
02037: t = jj_consume_token(CATCH);
02038: jj_consume_token(OPEN);
02039: AssignableExpression();
02040: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02041: case COLON:
02042: jj_consume_token(COLON);
02043: Expression();
02044: count++;
02045: label_19: while (true) {
02046: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02047: case COMMA:
02048: ;
02049: break;
02050: default:
02051: jj_la1[54] = jj_gen;
02052: break label_19;
02053: }
02054: jj_consume_token(COMMA);
02055: Expression();
02056: count++;
02057: }
02058: break;
02059: default:
02060: jj_la1[55] = jj_gen;
02061: ;
02062: }
02063: jj_consume_token(CLOSE);
02064: ExpressionList types = null;
02065: if (count > 0) {
02066: types = new ExpressionList(count);
02067: for (count--; count >= 0; count--) {
02068: types.setChild(count, ((Expression) pop()).getChild(0));
02069: }
02070: }
02071: Location location = toLocation(t);
02072: Expression assignment = (Expression) pop();
02073: Statement context = (trystmt != null) ? trystmt : flowPeek();
02074: if (trystmt == null) {
02075: trystmt = getEnclosingTryBlock();
02076: }
02077: CatchStatement catchstmt = new CatchStatement(trystmt,
02078: location, assignment, types);
02079: trystmt.addCatch(catchstmt);
02080: flowPush(catchstmt);
02081: Statement();
02082: flowPush(context);
02083: }
02084:
02085: final public void FinallyStatement(TryStatement trystmt)
02086: throws ParseException {
02087: Token t;
02088: Token param;
02089: t = jj_consume_token(FINALLY);
02090: Location location = toLocation(t);
02091: Statement context = (trystmt != null) ? trystmt : flowPeek();
02092: if (trystmt == null) {
02093: trystmt = getEnclosingTryBlock();
02094: }
02095: FinallyStatement finallystmt = new FinallyStatement(trystmt,
02096: toLocation(t));
02097: trystmt.setFinally(finallystmt);
02098: flowPush(finallystmt);
02099: Statement();
02100: flowPush(context);
02101: }
02102:
02103: final public void SynchronizedStatement() throws ParseException {
02104: Token t;
02105: t = jj_consume_token(SYNCHRONIZED);
02106: jj_consume_token(OPEN);
02107: Expression();
02108: jj_consume_token(CLOSE);
02109: flowPushChild(new SynchronizedStatement(flowPeek(),
02110: toLocation(t), (Expression) pop()));
02111: Statement();
02112: flowPop();
02113: }
02114:
02115: final public void ExpressionStatement() throws ParseException {
02116: Statement stmt;
02117: Expression();
02118: Expression expr = (Expression) pop();
02119: stmt = new EvalStatement(flowPeek(), expr.getLocation(), expr);
02120: StatementModifier(stmt);
02121: }
02122:
02123: final public void EmptyStatement() throws ParseException {
02124: jj_consume_token(SEMICOLON);
02125: }
02126:
02127: final public Expression[] PrintValueList(Expression suffix)
02128: throws ParseException {
02129: ArrayList list = new ArrayList();
02130: Token t;
02131: ValueExpression();
02132: list.add((Expression) pop());
02133: label_20: while (true) {
02134: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02135: case COMMA:
02136: ;
02137: break;
02138: default:
02139: jj_la1[56] = jj_gen;
02140: break label_20;
02141: }
02142: t = jj_consume_token(COMMA);
02143: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02144: case COMMA:
02145: jj_consume_token(COMMA);
02146: StringBuffer spaces = new StringBuffer(" ");
02147: label_21: while (true) {
02148: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02149: case COMMA:
02150: ;
02151: break;
02152: default:
02153: jj_la1[57] = jj_gen;
02154: break label_21;
02155: }
02156: jj_consume_token(COMMA);
02157: spaces.append(' ');
02158: }
02159: list.add(new Expression(new ConstantNode(spaces
02160: .toString()), toLocation(t)));
02161: break;
02162: default:
02163: jj_la1[58] = jj_gen;
02164: ;
02165: }
02166: ValueExpression();
02167: list.add((Expression) pop());
02168: }
02169: if (suffix != null) {
02170: list.add(suffix);
02171: }
02172: {
02173: if (true)
02174: return (Expression[]) list.toArray(new Expression[list
02175: .size()]);
02176: }
02177: throw new Error("Missing return statement in function");
02178: }
02179:
02180: final public void PrintStatement() throws ParseException {
02181: Token t;
02182: Expression[] list = null;
02183: Statement stmt;
02184: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02185: case PRINT:
02186: t = jj_consume_token(PRINT);
02187: list = PrintValueList(null);
02188: stmt = new PrintStatement(flowPeek(), toLocation(t), list,
02189: false);
02190: break;
02191: case HOOK:
02192: t = jj_consume_token(HOOK);
02193: list = PrintValueList(null);
02194: stmt = new PrintStatement(flowPeek(), toLocation(t), list,
02195: false);
02196: break;
02197: case PRINTLN:
02198: t = jj_consume_token(PRINTLN);
02199: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02200: case MODULE:
02201: case SYMBOL:
02202: case BEGIN:
02203: case DOT:
02204: case STAR:
02205: case IMPORT:
02206: case STRING_LITERAL:
02207: case RANGE:
02208: case FUNCTION:
02209: case OPEN:
02210: case SUPER:
02211: case STATIC:
02212: case CLASS:
02213: case VAR:
02214: case ET:
02215: case NEGATION:
02216: case PLUS:
02217: case MINUS:
02218: case MINUSMINUS:
02219: case PLUSPLUS:
02220: case COPYOF:
02221: case CLONEOF:
02222: case TYPEOF:
02223: case SIZEOF:
02224: case CLASSOF:
02225: case BOOLEAN:
02226: case INT:
02227: case FLOAT:
02228: case STRING:
02229: case DEFINED:
02230: case UNDEFINED:
02231: case NULL:
02232: case OPEN_BRACKET:
02233: case CARET:
02234: case DELETE:
02235: case BEGIN_LIST:
02236: case NEW:
02237: case THIS:
02238: case INTEGER_LITERAL:
02239: case FLOATING_POINT_LITERAL:
02240: case INF:
02241: case FALSE:
02242: case TRUE:
02243: case PATTERN:
02244: list = PrintValueList(null);
02245: break;
02246: default:
02247: jj_la1[59] = jj_gen;
02248: ;
02249: }
02250: if (list == null) {
02251: list = new Expression[0];
02252: }
02253: stmt = new PrintStatement(flowPeek(), toLocation(t), list,
02254: true);
02255: break;
02256: case PRINTBR:
02257: t = jj_consume_token(PRINTBR);
02258: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02259: case MODULE:
02260: case SYMBOL:
02261: case BEGIN:
02262: case DOT:
02263: case STAR:
02264: case IMPORT:
02265: case STRING_LITERAL:
02266: case RANGE:
02267: case FUNCTION:
02268: case OPEN:
02269: case SUPER:
02270: case STATIC:
02271: case CLASS:
02272: case VAR:
02273: case ET:
02274: case NEGATION:
02275: case PLUS:
02276: case MINUS:
02277: case MINUSMINUS:
02278: case PLUSPLUS:
02279: case COPYOF:
02280: case CLONEOF:
02281: case TYPEOF:
02282: case SIZEOF:
02283: case CLASSOF:
02284: case BOOLEAN:
02285: case INT:
02286: case FLOAT:
02287: case STRING:
02288: case DEFINED:
02289: case UNDEFINED:
02290: case NULL:
02291: case OPEN_BRACKET:
02292: case CARET:
02293: case DELETE:
02294: case BEGIN_LIST:
02295: case NEW:
02296: case THIS:
02297: case INTEGER_LITERAL:
02298: case FLOATING_POINT_LITERAL:
02299: case INF:
02300: case FALSE:
02301: case TRUE:
02302: case PATTERN:
02303: list = PrintValueList(new Expression(new ConstantNode(
02304: "<br>\n"), null));
02305: break;
02306: default:
02307: jj_la1[60] = jj_gen;
02308: ;
02309: }
02310: if (list == null) {
02311: list = new Expression[0];
02312: }
02313: stmt = new PrintStatement(flowPeek(), toLocation(t), list,
02314: false);
02315: break;
02316: default:
02317: jj_la1[61] = jj_gen;
02318: jj_consume_token(-1);
02319: throw new ParseException();
02320: }
02321: StatementModifier(stmt);
02322: }
02323:
02324: final public void IfStatement() throws ParseException {
02325: Token t;
02326: IfStatement stmt;
02327: t = jj_consume_token(IF);
02328: jj_consume_token(OPEN);
02329: Expression();
02330: jj_consume_token(CLOSE);
02331: stmt = new IfStatement(flowPeek(), toLocation(t),
02332: (Expression) pop());
02333: flowPushChild(stmt);
02334: Statement();
02335: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02336: case ELSE:
02337: jj_consume_token(ELSE);
02338: stmt.onElse();
02339: Statement();
02340: break;
02341: default:
02342: jj_la1[62] = jj_gen;
02343: ;
02344: }
02345: flowPop();
02346: }
02347:
02348: final public String StatementLabel() throws ParseException {
02349: Token t;
02350: t = jj_consume_token(SYMBOL);
02351: jj_consume_token(COLON);
02352: String label = t.image;
02353: if (flowPeek().allowLabel(label)) {
02354: error(toLocation(t), "Label '" + label
02355: + "' is already declared");
02356: label = null;
02357: }
02358: {
02359: if (true)
02360: return label;
02361: }
02362: throw new Error("Missing return statement in function");
02363: }
02364:
02365: final public void SwitchStatement(String label)
02366: throws ParseException {
02367: Token t;
02368: Case caze;
02369: SwitchStatement stmt;
02370: t = jj_consume_token(SWITCH);
02371: jj_consume_token(OPEN);
02372: Expression();
02373: jj_consume_token(CLOSE);
02374: jj_consume_token(BEGIN);
02375: stmt = new SwitchStatement(flowPeek(), toLocation(t),
02376: (Expression) pop(), label);
02377: flowPushChild(stmt);
02378: label_22: while (true) {
02379: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02380: case CASE:
02381: case _DEFAULT:
02382: ;
02383: break;
02384: default:
02385: jj_la1[63] = jj_gen;
02386: break label_22;
02387: }
02388: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02389: case CASE:
02390: t = jj_consume_token(CASE);
02391: ValueExpression();
02392: caze = stmt.onCase(this , (Expression) pop());
02393: label_23: while (true) {
02394: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02395: case COMMA:
02396: ;
02397: break;
02398: default:
02399: jj_la1[64] = jj_gen;
02400: break label_23;
02401: }
02402: jj_consume_token(COMMA);
02403: ValueExpression();
02404: caze = stmt.onCase(this , (Expression) pop());
02405: }
02406: flowPush(caze.getBlock());
02407: jj_consume_token(COLON);
02408: label_24: while (true) {
02409: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02410: case MODULE:
02411: case SYMBOL:
02412: case BEGIN:
02413: case DOT:
02414: case STAR:
02415: case IMPORT:
02416: case STRING_LITERAL:
02417: case SEMICOLON:
02418: case RANGE:
02419: case FUNCTION:
02420: case OPEN:
02421: case SUPER:
02422: case SYNCHRONIZED:
02423: case STATIC:
02424: case CLASS:
02425: case VAR:
02426: case IF:
02427: case WHILE:
02428: case TRY:
02429: case CATCH:
02430: case FINALLY:
02431: case THROW:
02432: case PRINT:
02433: case HOOK:
02434: case PRINTLN:
02435: case PRINTBR:
02436: case SWITCH:
02437: case FOR:
02438: case DO:
02439: case FOREACH:
02440: case BREAK:
02441: case CONTINUE:
02442: case EXIT:
02443: case RETURN:
02444: case YIELD:
02445: case ASSERT:
02446: case ET:
02447: case NEGATION:
02448: case PLUS:
02449: case MINUS:
02450: case MINUSMINUS:
02451: case PLUSPLUS:
02452: case COPYOF:
02453: case CLONEOF:
02454: case TYPEOF:
02455: case SIZEOF:
02456: case CLASSOF:
02457: case BOOLEAN:
02458: case INT:
02459: case FLOAT:
02460: case STRING:
02461: case DEFINED:
02462: case UNDEFINED:
02463: case NULL:
02464: case OPEN_BRACKET:
02465: case CARET:
02466: case DELETE:
02467: case BEGIN_LIST:
02468: case NEW:
02469: case THIS:
02470: case INTEGER_LITERAL:
02471: case FLOATING_POINT_LITERAL:
02472: case INF:
02473: case FALSE:
02474: case TRUE:
02475: case PATTERN:
02476: ;
02477: break;
02478: default:
02479: jj_la1[65] = jj_gen;
02480: break label_24;
02481: }
02482: Statement();
02483: }
02484: flowPop();
02485: break;
02486: case _DEFAULT:
02487: t = jj_consume_token(_DEFAULT);
02488: jj_consume_token(COLON);
02489: caze = stmt.onDefault(this , toLocation(t));
02490: flowPush(caze.getBlock());
02491: label_25: while (true) {
02492: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02493: case MODULE:
02494: case SYMBOL:
02495: case BEGIN:
02496: case DOT:
02497: case STAR:
02498: case IMPORT:
02499: case STRING_LITERAL:
02500: case SEMICOLON:
02501: case RANGE:
02502: case FUNCTION:
02503: case OPEN:
02504: case SUPER:
02505: case SYNCHRONIZED:
02506: case STATIC:
02507: case CLASS:
02508: case VAR:
02509: case IF:
02510: case WHILE:
02511: case TRY:
02512: case CATCH:
02513: case FINALLY:
02514: case THROW:
02515: case PRINT:
02516: case HOOK:
02517: case PRINTLN:
02518: case PRINTBR:
02519: case SWITCH:
02520: case FOR:
02521: case DO:
02522: case FOREACH:
02523: case BREAK:
02524: case CONTINUE:
02525: case EXIT:
02526: case RETURN:
02527: case YIELD:
02528: case ASSERT:
02529: case ET:
02530: case NEGATION:
02531: case PLUS:
02532: case MINUS:
02533: case MINUSMINUS:
02534: case PLUSPLUS:
02535: case COPYOF:
02536: case CLONEOF:
02537: case TYPEOF:
02538: case SIZEOF:
02539: case CLASSOF:
02540: case BOOLEAN:
02541: case INT:
02542: case FLOAT:
02543: case STRING:
02544: case DEFINED:
02545: case UNDEFINED:
02546: case NULL:
02547: case OPEN_BRACKET:
02548: case CARET:
02549: case DELETE:
02550: case BEGIN_LIST:
02551: case NEW:
02552: case THIS:
02553: case INTEGER_LITERAL:
02554: case FLOATING_POINT_LITERAL:
02555: case INF:
02556: case FALSE:
02557: case TRUE:
02558: case PATTERN:
02559: ;
02560: break;
02561: default:
02562: jj_la1[66] = jj_gen;
02563: break label_25;
02564: }
02565: Statement();
02566: }
02567: flowPop();
02568: break;
02569: default:
02570: jj_la1[67] = jj_gen;
02571: jj_consume_token(-1);
02572: throw new ParseException();
02573: }
02574: }
02575: jj_consume_token(END);
02576: flowPop();
02577: }
02578:
02579: final public void WhileStatement(String label)
02580: throws ParseException {
02581: Token t;
02582: t = jj_consume_token(WHILE);
02583: jj_consume_token(OPEN);
02584: Expression();
02585: jj_consume_token(CLOSE);
02586: flowPushChild(new WhileStatement(flowPeek(), toLocation(t),
02587: (Expression) pop(), label));
02588: Statement();
02589: flowPop();
02590: }
02591:
02592: final public void ForAssignmentExpression(Token t)
02593: throws ParseException {
02594: Expression();
02595: }
02596:
02597: final public Object[] TerminalForExpressionList()
02598: throws ParseException {
02599: Object[] list;
02600: list = ForExpressionList(null);
02601: jj_consume_token(0);
02602: {
02603: if (true)
02604: return list;
02605: }
02606: throw new Error("Missing return statement in function");
02607: }
02608:
02609: final public Object[] ForExpressionList(Token t)
02610: throws ParseException {
02611: Expression[] init = null;
02612: Expression condition = null;
02613: Expression[] action = null;
02614: int n;
02615: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02616: case MODULE:
02617: case SYMBOL:
02618: case BEGIN:
02619: case DOT:
02620: case STAR:
02621: case IMPORT:
02622: case STRING_LITERAL:
02623: case RANGE:
02624: case FUNCTION:
02625: case OPEN:
02626: case SUPER:
02627: case STATIC:
02628: case CLASS:
02629: case VAR:
02630: case ET:
02631: case NEGATION:
02632: case PLUS:
02633: case MINUS:
02634: case MINUSMINUS:
02635: case PLUSPLUS:
02636: case COPYOF:
02637: case CLONEOF:
02638: case TYPEOF:
02639: case SIZEOF:
02640: case CLASSOF:
02641: case BOOLEAN:
02642: case INT:
02643: case FLOAT:
02644: case STRING:
02645: case DEFINED:
02646: case UNDEFINED:
02647: case NULL:
02648: case OPEN_BRACKET:
02649: case CARET:
02650: case DELETE:
02651: case BEGIN_LIST:
02652: case NEW:
02653: case THIS:
02654: case INTEGER_LITERAL:
02655: case FLOATING_POINT_LITERAL:
02656: case INF:
02657: case FALSE:
02658: case TRUE:
02659: case PATTERN:
02660: n = 0;
02661: ForAssignmentExpression(t);
02662: n++;
02663: label_26: while (true) {
02664: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02665: case COMMA:
02666: ;
02667: break;
02668: default:
02669: jj_la1[68] = jj_gen;
02670: break label_26;
02671: }
02672: t = jj_consume_token(COMMA);
02673: ForAssignmentExpression(t);
02674: n++;
02675: }
02676: init = new Expression[n];
02677: for (int i = n - 1; i >= 0; i--) {
02678: init[i] = (Expression) pop();
02679: }
02680: break;
02681: default:
02682: jj_la1[69] = jj_gen;
02683: ;
02684: }
02685: jj_consume_token(SEMICOLON);
02686: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02687: case MODULE:
02688: case SYMBOL:
02689: case BEGIN:
02690: case DOT:
02691: case STAR:
02692: case IMPORT:
02693: case STRING_LITERAL:
02694: case RANGE:
02695: case FUNCTION:
02696: case OPEN:
02697: case SUPER:
02698: case STATIC:
02699: case CLASS:
02700: case VAR:
02701: case ET:
02702: case NEGATION:
02703: case PLUS:
02704: case MINUS:
02705: case MINUSMINUS:
02706: case PLUSPLUS:
02707: case COPYOF:
02708: case CLONEOF:
02709: case TYPEOF:
02710: case SIZEOF:
02711: case CLASSOF:
02712: case BOOLEAN:
02713: case INT:
02714: case FLOAT:
02715: case STRING:
02716: case DEFINED:
02717: case UNDEFINED:
02718: case NULL:
02719: case OPEN_BRACKET:
02720: case CARET:
02721: case DELETE:
02722: case BEGIN_LIST:
02723: case NEW:
02724: case THIS:
02725: case INTEGER_LITERAL:
02726: case FLOATING_POINT_LITERAL:
02727: case INF:
02728: case FALSE:
02729: case TRUE:
02730: case PATTERN:
02731: Expression();
02732: condition = (Expression) pop();
02733: break;
02734: default:
02735: jj_la1[70] = jj_gen;
02736: ;
02737: }
02738: t = jj_consume_token(SEMICOLON);
02739: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02740: case MODULE:
02741: case SYMBOL:
02742: case BEGIN:
02743: case DOT:
02744: case STAR:
02745: case IMPORT:
02746: case STRING_LITERAL:
02747: case RANGE:
02748: case FUNCTION:
02749: case OPEN:
02750: case SUPER:
02751: case STATIC:
02752: case CLASS:
02753: case VAR:
02754: case ET:
02755: case NEGATION:
02756: case PLUS:
02757: case MINUS:
02758: case MINUSMINUS:
02759: case PLUSPLUS:
02760: case COPYOF:
02761: case CLONEOF:
02762: case TYPEOF:
02763: case SIZEOF:
02764: case CLASSOF:
02765: case BOOLEAN:
02766: case INT:
02767: case FLOAT:
02768: case STRING:
02769: case DEFINED:
02770: case UNDEFINED:
02771: case NULL:
02772: case OPEN_BRACKET:
02773: case CARET:
02774: case DELETE:
02775: case BEGIN_LIST:
02776: case NEW:
02777: case THIS:
02778: case INTEGER_LITERAL:
02779: case FLOATING_POINT_LITERAL:
02780: case INF:
02781: case FALSE:
02782: case TRUE:
02783: case PATTERN:
02784: n = 0;
02785: ForAssignmentExpression(t);
02786: n++;
02787: label_27: while (true) {
02788: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02789: case COMMA:
02790: ;
02791: break;
02792: default:
02793: jj_la1[71] = jj_gen;
02794: break label_27;
02795: }
02796: t = jj_consume_token(COMMA);
02797: ForAssignmentExpression(t);
02798: n++;
02799: }
02800: action = new Expression[n];
02801: for (int i = n - 1; i >= 0; i--) {
02802: action[i] = (Expression) pop();
02803: }
02804: break;
02805: default:
02806: jj_la1[72] = jj_gen;
02807: ;
02808: }
02809: {
02810: if (true)
02811: return new Object[] { init, condition, action };
02812: }
02813: throw new Error("Missing return statement in function");
02814: }
02815:
02816: final public void ForStatement(String label) throws ParseException {
02817: Token t;
02818: Object[] list;
02819: t = jj_consume_token(FOR);
02820: jj_consume_token(OPEN);
02821: list = ForExpressionList(t);
02822: jj_consume_token(CLOSE);
02823: flowPushChild(new ForStatement(flowPeek(), toLocation(t),
02824: (Expression[]) list[0], (Expression) list[1],
02825: (Expression[]) list[2], label));
02826: Statement();
02827: flowPop();
02828: }
02829:
02830: final public void DoStatement(String label) throws ParseException {
02831: Token t;
02832: DoStatement stmt;
02833: t = jj_consume_token(DO);
02834: stmt = new DoStatement(flowPeek(), toLocation(t), label);
02835: flowPushChild(stmt);
02836: Statement();
02837: jj_consume_token(WHILE);
02838: jj_consume_token(OPEN);
02839: Expression();
02840: jj_consume_token(CLOSE);
02841: jj_consume_token(SEMICOLON);
02842: stmt.onWhile((Expression) pop());
02843: flowPop();
02844: }
02845:
02846: final public void ForeachStatement(String label)
02847: throws ParseException {
02848: ForeachStatement foreach = null;
02849: foreach = ForeachStatementHeader(flowPeek(), label);
02850: flowPushChild(foreach);
02851: Statement();
02852: flowPop();
02853: }
02854:
02855: final public Expression[] ForeachExpressions()
02856: throws ParseException {
02857: int count = 0;
02858: AssignableExpression();
02859: count++;
02860: label_28: while (true) {
02861: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02862: case COMMA:
02863: ;
02864: break;
02865: default:
02866: jj_la1[73] = jj_gen;
02867: break label_28;
02868: }
02869: jj_consume_token(COMMA);
02870: AssignableExpression();
02871: count++;
02872: }
02873: Expression[] list = new Expression[count];
02874: for (int i = count - 1; i >= 0; i--) {
02875: list[i] = (Expression) pop();
02876: }
02877: {
02878: if (true)
02879: return list;
02880: }
02881: throw new Error("Missing return statement in function");
02882: }
02883:
02884: final public ForeachStatement ForeachStatementHeader(
02885: Statement parent, String label) throws ParseException {
02886: Token t;
02887: int count = 0;
02888: boolean third = false;
02889: Expression[] index = null;
02890: Expression[] key = null;
02891: Expression[] value = null;
02892: t = jj_consume_token(FOREACH);
02893: jj_consume_token(OPEN);
02894: if (jj_2_10(2147483647)) {
02895: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02896: case MODULE:
02897: case SYMBOL:
02898: case DOT:
02899: case FUNCTION:
02900: case SUPER:
02901: case STATIC:
02902: case CLASS:
02903: case VAR:
02904: case THIS:
02905: index = ForeachExpressions();
02906: break;
02907: default:
02908: jj_la1[74] = jj_gen;
02909: ;
02910: }
02911: jj_consume_token(SEMICOLON);
02912: count++;
02913: } else {
02914: ;
02915: }
02916: if (jj_2_11(2147483647)) {
02917: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02918: case MODULE:
02919: case SYMBOL:
02920: case DOT:
02921: case FUNCTION:
02922: case SUPER:
02923: case STATIC:
02924: case CLASS:
02925: case VAR:
02926: case THIS:
02927: key = ForeachExpressions();
02928: break;
02929: default:
02930: jj_la1[75] = jj_gen;
02931: ;
02932: }
02933: jj_consume_token(SEMICOLON);
02934: count++;
02935: } else {
02936: ;
02937: }
02938: if (jj_2_12(2147483647)) {
02939: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02940: case MODULE:
02941: case SYMBOL:
02942: case DOT:
02943: case FUNCTION:
02944: case SUPER:
02945: case STATIC:
02946: case CLASS:
02947: case VAR:
02948: case THIS:
02949: value = ForeachExpressions();
02950: break;
02951: default:
02952: jj_la1[76] = jj_gen;
02953: ;
02954: }
02955: jj_consume_token(SEMICOLON);
02956: count++;
02957: } else {
02958: ;
02959: }
02960: Expression();
02961: jj_consume_token(CLOSE);
02962: Expression expr = (Expression) pop();
02963: switch (count) {
02964: case 1:
02965: value = index;
02966: key = null;
02967: index = null;
02968: break;
02969: case 2:
02970: if (key != null) {
02971: value = key;
02972: key = null;
02973: }
02974: if (index != null) {
02975: key = index;
02976: index = null;
02977: }
02978: break;
02979: case 3:
02980: }
02981: {
02982: if (true)
02983: return new ForeachStatement(parent, toLocation(t),
02984: index, key, value, expr, label);
02985: }
02986: throw new Error("Missing return statement in function");
02987: }
02988:
02989: final public void BreakStatement() throws ParseException {
02990: Token t;
02991: Token s = null;
02992: Statement stmt;
02993: t = jj_consume_token(BREAK);
02994: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02995: case SYMBOL:
02996: s = jj_consume_token(SYMBOL);
02997: break;
02998: default:
02999: jj_la1[77] = jj_gen;
03000: ;
03001: }
03002: int depth = 0;
03003: String label = ((s != null) ? s.image : null);
03004: if (flowPeek().allowBreak()) {
03005: if (label != null) {
03006: if (flowPeek().allowLabel(label)) {
03007: depth = flowPeek().getLabelDepth(label);
03008: } else {
03009: error(toLocation(t), "Label '" + label
03010: + "' is not declared");
03011: }
03012: }
03013: } else {
03014: error(toLocation(t),
03015: "Superfluous break, no valid enclosing statements open");
03016: }
03017: stmt = new BreakStatement(flowPeek(), toLocation(t), label,
03018: depth);
03019: StatementModifier(stmt);
03020: }
03021:
03022: final public void ContinueStatement() throws ParseException {
03023: Token t;
03024: Token s = null;
03025: String label = null;
03026: int target = 0;
03027: Expression expr = null;
03028: Statement stmt;
03029: t = jj_consume_token(CONTINUE);
03030: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03031: case SYMBOL:
03032: s = jj_consume_token(SYMBOL);
03033: label = s.image;
03034: break;
03035: default:
03036: jj_la1[78] = jj_gen;
03037: ;
03038: }
03039: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03040: case CASE:
03041: case _DEFAULT:
03042: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03043: case CASE:
03044: jj_consume_token(CASE);
03045: ValueExpression();
03046: target = Statement.ST_CASE;
03047: expr = (Expression) pop();
03048: break;
03049: case _DEFAULT:
03050: jj_consume_token(_DEFAULT);
03051: target = Statement.ST_DEFAULT;
03052: break;
03053: default:
03054: jj_la1[79] = jj_gen;
03055: jj_consume_token(-1);
03056: throw new ParseException();
03057: }
03058: break;
03059: default:
03060: jj_la1[80] = jj_gen;
03061: ;
03062: }
03063: stmt = flowPeek();
03064: int depth = 0;
03065: if ((target == 0) ? stmt.allowContinue() : stmt.allowBreak()) {
03066: if (label != null) {
03067: if (stmt.allowLabel(label)) {
03068: depth = stmt.getLabelDepth(label);
03069: } else {
03070: error(toLocation(t), "Label '" + label
03071: + "' is not declared");
03072: }
03073: }
03074: } else {
03075: error(toLocation(t),
03076: "Superfluous continue, no valid enclosing statements open");
03077: }
03078: stmt = new ContinueStatement(flowPeek(), toLocation(t), label,
03079: depth, target, expr);
03080: StatementModifier(stmt);
03081: }
03082:
03083: final public void ExitStatement() throws ParseException {
03084: Token t;
03085: Expression expr = null;
03086: t = jj_consume_token(EXIT);
03087: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03088: case MODULE:
03089: case SYMBOL:
03090: case BEGIN:
03091: case DOT:
03092: case STAR:
03093: case IMPORT:
03094: case STRING_LITERAL:
03095: case RANGE:
03096: case FUNCTION:
03097: case OPEN:
03098: case SUPER:
03099: case STATIC:
03100: case CLASS:
03101: case VAR:
03102: case ET:
03103: case NEGATION:
03104: case PLUS:
03105: case MINUS:
03106: case MINUSMINUS:
03107: case PLUSPLUS:
03108: case COPYOF:
03109: case CLONEOF:
03110: case TYPEOF:
03111: case SIZEOF:
03112: case CLASSOF:
03113: case BOOLEAN:
03114: case INT:
03115: case FLOAT:
03116: case STRING:
03117: case DEFINED:
03118: case UNDEFINED:
03119: case NULL:
03120: case OPEN_BRACKET:
03121: case CARET:
03122: case DELETE:
03123: case BEGIN_LIST:
03124: case NEW:
03125: case THIS:
03126: case INTEGER_LITERAL:
03127: case FLOATING_POINT_LITERAL:
03128: case INF:
03129: case FALSE:
03130: case TRUE:
03131: case PATTERN:
03132: ListExpression();
03133: expr = (Expression) pop();
03134: break;
03135: default:
03136: jj_la1[81] = jj_gen;
03137: ;
03138: }
03139: StatementModifier(new ExitStatement(flowPeek(), toLocation(t),
03140: expr));
03141: }
03142:
03143: final public void ReturnStatement() throws ParseException {
03144: Token t;
03145: Expression expression = null;
03146: Statement stmt;
03147: t = jj_consume_token(RETURN);
03148: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03149: case MODULE:
03150: case SYMBOL:
03151: case BEGIN:
03152: case DOT:
03153: case STAR:
03154: case IMPORT:
03155: case STRING_LITERAL:
03156: case RANGE:
03157: case FUNCTION:
03158: case OPEN:
03159: case SUPER:
03160: case STATIC:
03161: case CLASS:
03162: case VAR:
03163: case ET:
03164: case NEGATION:
03165: case PLUS:
03166: case MINUS:
03167: case MINUSMINUS:
03168: case PLUSPLUS:
03169: case COPYOF:
03170: case CLONEOF:
03171: case TYPEOF:
03172: case SIZEOF:
03173: case CLASSOF:
03174: case BOOLEAN:
03175: case INT:
03176: case FLOAT:
03177: case STRING:
03178: case DEFINED:
03179: case UNDEFINED:
03180: case NULL:
03181: case OPEN_BRACKET:
03182: case CARET:
03183: case DELETE:
03184: case BEGIN_LIST:
03185: case NEW:
03186: case THIS:
03187: case INTEGER_LITERAL:
03188: case FLOATING_POINT_LITERAL:
03189: case INF:
03190: case FALSE:
03191: case TRUE:
03192: case PATTERN:
03193: ListExpression();
03194: expression = (Expression) pop();
03195: break;
03196: default:
03197: jj_la1[82] = jj_gen;
03198: ;
03199: }
03200: if (flowPeek().getFunctionStatement().getType() == Type.CONSTRUCTOR) {
03201: if (expression != null) {
03202: error(toLocation(t),
03203: "Constructors cannot have return values");
03204: expression = null;
03205: }
03206: } else {
03207: if (expression == null) {
03208: expression = Expression.UNDEFINED;
03209: }
03210: }
03211: stmt = new ReturnStatement(flowPeek(), toLocation(t),
03212: expression);
03213: StatementModifier(stmt);
03214: }
03215:
03216: final public void YieldStatement() throws ParseException {
03217: Token t;
03218: Expression expression = null;
03219: Statement stmt;
03220: t = jj_consume_token(YIELD);
03221: ListExpression();
03222: expression = (Expression) pop();
03223: if (flowPeek().getFunctionStatement().getType() == Type.CONSTRUCTOR) {
03224: if (expression != null) {
03225: error(toLocation(t),
03226: "Constructors cannot be generators");
03227: }
03228: }
03229: stmt = new YieldStatement(flowPeek(), toLocation(t), expression);
03230: StatementModifier(stmt);
03231: }
03232:
03233: final public void AssertStatement() throws ParseException {
03234: Token start;
03235: Token end;
03236: start = jj_consume_token(ASSERT);
03237: Expression();
03238: end = jj_consume_token(SEMICOLON);
03239: StringBuffer buf = new StringBuffer();
03240: Token p = start.next;
03241: while (p != end && p != null) {
03242: buf.append(p.image);
03243: p = p.next;
03244: }
03245: AssertStatement stmt = new AssertStatement(flowPeek(),
03246: toLocation(start), (Expression) pop(), buf.toString());
03247: flowPushChild(stmt);
03248: flowPop();
03249: }
03250:
03251: /*
03252: * Expression(s) starts here
03253: */
03254: final public void TerminalArgumentList() throws ParseException {
03255: ArgumentList();
03256: jj_consume_token(0);
03257: }
03258:
03259: final public void TerminalValueExpression() throws ParseException {
03260: ValueExpression();
03261: jj_consume_token(0);
03262: }
03263:
03264: final public void TerminalAssignableExpression()
03265: throws ParseException {
03266: AssignableExpression();
03267: jj_consume_token(0);
03268: }
03269:
03270: final public void TerminalExpression() throws ParseException {
03271: Expression();
03272: jj_consume_token(0);
03273: }
03274:
03275: final public void TerminalList() throws ParseException {
03276: List(true, false);
03277: jj_consume_token(0);
03278: }
03279:
03280: final public void TerminalAssignmentExpression()
03281: throws ParseException {
03282: AssignmentExpression();
03283: jj_consume_token(0);
03284: }
03285:
03286: final public Expression[] TerminalForeachAssignmentExpression()
03287: throws ParseException {
03288: Expression[] exprs;
03289: exprs = ForeachExpressions();
03290: jj_consume_token(0);
03291: {
03292: if (true)
03293: return exprs;
03294: }
03295: throw new Error("Missing return statement in function");
03296: }
03297:
03298: final public void Expression() throws ParseException {
03299: if (jj_2_13(2147483647)) {
03300: AssignmentExpression();
03301: } else {
03302: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03303: case MODULE:
03304: case SYMBOL:
03305: case BEGIN:
03306: case DOT:
03307: case STAR:
03308: case IMPORT:
03309: case STRING_LITERAL:
03310: case RANGE:
03311: case FUNCTION:
03312: case OPEN:
03313: case SUPER:
03314: case STATIC:
03315: case CLASS:
03316: case VAR:
03317: case ET:
03318: case NEGATION:
03319: case PLUS:
03320: case MINUS:
03321: case MINUSMINUS:
03322: case PLUSPLUS:
03323: case COPYOF:
03324: case CLONEOF:
03325: case TYPEOF:
03326: case SIZEOF:
03327: case CLASSOF:
03328: case BOOLEAN:
03329: case INT:
03330: case FLOAT:
03331: case STRING:
03332: case DEFINED:
03333: case UNDEFINED:
03334: case NULL:
03335: case OPEN_BRACKET:
03336: case CARET:
03337: case DELETE:
03338: case BEGIN_LIST:
03339: case NEW:
03340: case THIS:
03341: case INTEGER_LITERAL:
03342: case FLOATING_POINT_LITERAL:
03343: case INF:
03344: case FALSE:
03345: case TRUE:
03346: case PATTERN:
03347: ValueExpression();
03348: break;
03349: default:
03350: jj_la1[83] = jj_gen;
03351: jj_consume_token(-1);
03352: throw new ParseException();
03353: }
03354: }
03355: }
03356:
03357: final public void ListExpression() throws ParseException {
03358: Location loc = getCurrentLocation();
03359: List(false, false);
03360: push(new Expression(pop(), loc));
03361: }
03362:
03363: final public void ValueExpression() throws ParseException {
03364: Location loc = getCurrentLocation();
03365: ExpressionStart();
03366: push(new Expression(pop(), loc));
03367: }
03368:
03369: final public void AssignmentExpression() throws ParseException {
03370: int count = 0;
03371: Token op;
03372: Token et = null;
03373: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03374: case ET:
03375: et = jj_consume_token(ET);
03376: break;
03377: default:
03378: jj_la1[84] = jj_gen;
03379: ;
03380: }
03381: Symbol(LinkNode.ASSIGN);
03382: if (et != null) {
03383: push(new RefNode(toLocation(et), pop(), true));
03384: }
03385: count++;
03386: label_29: while (true) {
03387: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03388: case COMMA:
03389: ;
03390: break;
03391: default:
03392: jj_la1[85] = jj_gen;
03393: break label_29;
03394: }
03395: jj_consume_token(COMMA);
03396: et = null;
03397: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03398: case ET:
03399: et = jj_consume_token(ET);
03400: break;
03401: default:
03402: jj_la1[86] = jj_gen;
03403: ;
03404: }
03405: Symbol(LinkNode.ASSIGN);
03406: if (et != null) {
03407: push(new RefNode(toLocation(et), pop(), true));
03408: }
03409: count++;
03410: }
03411: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03412: case ASSIGN:
03413: op = jj_consume_token(ASSIGN);
03414: break;
03415: case ASSIGN_ADD:
03416: op = jj_consume_token(ASSIGN_ADD);
03417: break;
03418: case ASSIGN_SUBSTRACT:
03419: op = jj_consume_token(ASSIGN_SUBSTRACT);
03420: break;
03421: case ASSIGN_MULTIPLY:
03422: op = jj_consume_token(ASSIGN_MULTIPLY);
03423: break;
03424: case ASSIGN_DIVIDE:
03425: op = jj_consume_token(ASSIGN_DIVIDE);
03426: break;
03427: case ASSIGN_REMAINDER:
03428: op = jj_consume_token(ASSIGN_REMAINDER);
03429: break;
03430: case ASSIGN_CONCAT:
03431: op = jj_consume_token(ASSIGN_CONCAT);
03432: break;
03433: case ASSIGN_INIT:
03434: op = jj_consume_token(ASSIGN_INIT);
03435: break;
03436: default:
03437: jj_la1[87] = jj_gen;
03438: jj_consume_token(-1);
03439: throw new ParseException();
03440: }
03441: List(false, false);
03442: Location location = toLocation(op);
03443: Parent assignment = null;
03444: switch (op.kind) {
03445: case ASSIGN:
03446: assignment = new AssignmentNode(location, count + 1);
03447: break;
03448: case ASSIGN_ADD:
03449: assignment = new AdditionAssignmentNode(location, count + 1);
03450: break;
03451: case ASSIGN_SUBSTRACT:
03452: assignment = new SubtractionAssignmentNode(location,
03453: count + 1);
03454: break;
03455: case ASSIGN_MULTIPLY:
03456: assignment = new MultiplicationAssignmentNode(location,
03457: count + 1);
03458: break;
03459: case ASSIGN_DIVIDE:
03460: assignment = new DivisionAssignmentNode(location, count + 1);
03461: break;
03462: case ASSIGN_REMAINDER:
03463: assignment = new ModuloAssignmentNode(location, count + 1);
03464: break;
03465: case ASSIGN_CONCAT:
03466: assignment = new ConcatenationAssignmentNode(location,
03467: count + 1);
03468: break;
03469: case ASSIGN_INIT:
03470: assignment = new InitAssignmentNode(location, count + 1);
03471: break;
03472: }
03473: assignment.setChild(count, pop());
03474: while (count-- > 0) {
03475: assignment.setChild(count, pop());
03476: }
03477: push(new Expression(assignment, location));
03478: }
03479:
03480: final public void AssignableExpression() throws ParseException {
03481: Location loc = getCurrentLocation();
03482: Symbol(LinkNode.ASSIGN);
03483: push(new Expression(pop(), loc));
03484: }
03485:
03486: final public void List(boolean forcelist, boolean mutable)
03487: throws ParseException {
03488: int argc = 1;
03489: Expression();
03490: label_30: while (true) {
03491: if (jj_2_14(2)) {
03492: ;
03493: } else {
03494: break label_30;
03495: }
03496: jj_consume_token(COMMA);
03497: ExpressionStart();
03498: argc++;
03499: }
03500: if (jj_2_15(2)) {
03501: jj_consume_token(COMMA);
03502: forcelist = true;
03503: } else {
03504: ;
03505: }
03506: if (forcelist || (argc > 1)) {
03507: if (mutable) {
03508: MutableExpressionList list = new MutableExpressionList(
03509: argc);
03510: while (argc-- > 0) {
03511: list.setChild(argc, pop());
03512: }
03513: push(list);
03514: } else {
03515: ExpressionList list = new ExpressionList(argc);
03516: while (argc-- > 0) {
03517: list.setChild(argc, pop());
03518: }
03519: push(list);
03520: }
03521: }
03522: }
03523:
03524: final public void ExpressionStart() throws ParseException {
03525: ForeachExpression();
03526: }
03527:
03528: final public void ForeachExpression() throws ParseException {
03529: PipeExpression();
03530: label_31: while (true) {
03531: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03532: case FOREACH:
03533: ;
03534: break;
03535: default:
03536: jj_la1[88] = jj_gen;
03537: break label_31;
03538: }
03539: jj_consume_token(FOREACH);
03540: InlineFunction();
03541: Node block = pop();
03542: Node self = pop();
03543: push(new ForeachNode(self, block));
03544: }
03545: }
03546:
03547: final public void PipeExpression() throws ParseException {
03548: MappingExpression();
03549: label_32: while (true) {
03550: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03551: case ARROW:
03552: ;
03553: break;
03554: default:
03555: jj_la1[89] = jj_gen;
03556: break label_32;
03557: }
03558: jj_consume_token(ARROW);
03559: MappingExpression();
03560: Node right = pop();
03561: Node left = pop();
03562: push(new PipeNode(left, right));
03563: }
03564: }
03565:
03566: final public void MappingExpression() throws ParseException {
03567: ConditionalExpression();
03568: label_33: while (true) {
03569: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03570: case MAP:
03571: ;
03572: break;
03573: default:
03574: jj_la1[90] = jj_gen;
03575: break label_33;
03576: }
03577: jj_consume_token(MAP);
03578: ConditionalExpression();
03579: Node right = pop();
03580: Node left = pop();
03581: push(new MappingNode(left, right));
03582: }
03583: }
03584:
03585: final public void ConditionalExpression() throws ParseException {
03586: Node right = ConstantNode.UNDEFINED;
03587: Node left;
03588: Node middle;
03589: RangeExpression();
03590: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03591: case HOOK:
03592: case HOOKHOOK:
03593: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03594: case HOOKHOOK:
03595: jj_consume_token(HOOKHOOK);
03596: ConditionalExpression();
03597: right = pop();
03598: left = pop();
03599: push(new SelectNode(left, right));
03600: break;
03601: case HOOK:
03602: jj_consume_token(HOOK);
03603: ConditionalExpression();
03604: jj_consume_token(COLON);
03605: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03606: case MODULE:
03607: case SYMBOL:
03608: case BEGIN:
03609: case DOT:
03610: case STAR:
03611: case IMPORT:
03612: case STRING_LITERAL:
03613: case RANGE:
03614: case FUNCTION:
03615: case OPEN:
03616: case SUPER:
03617: case STATIC:
03618: case CLASS:
03619: case VAR:
03620: case ET:
03621: case NEGATION:
03622: case PLUS:
03623: case MINUS:
03624: case MINUSMINUS:
03625: case PLUSPLUS:
03626: case COPYOF:
03627: case CLONEOF:
03628: case TYPEOF:
03629: case SIZEOF:
03630: case CLASSOF:
03631: case BOOLEAN:
03632: case INT:
03633: case FLOAT:
03634: case STRING:
03635: case DEFINED:
03636: case UNDEFINED:
03637: case NULL:
03638: case OPEN_BRACKET:
03639: case CARET:
03640: case DELETE:
03641: case BEGIN_LIST:
03642: case NEW:
03643: case THIS:
03644: case INTEGER_LITERAL:
03645: case FLOATING_POINT_LITERAL:
03646: case INF:
03647: case FALSE:
03648: case TRUE:
03649: case PATTERN:
03650: ConditionalExpression();
03651: right = pop();
03652: break;
03653: default:
03654: jj_la1[91] = jj_gen;
03655: ;
03656: }
03657: middle = pop();
03658: left = pop();
03659: push(new ConditionalNode(left, middle, right));
03660: break;
03661: default:
03662: jj_la1[92] = jj_gen;
03663: jj_consume_token(-1);
03664: throw new ParseException();
03665: }
03666: break;
03667: default:
03668: jj_la1[93] = jj_gen;
03669: ;
03670: }
03671: }
03672:
03673: final public void RangeExpression() throws ParseException {
03674: Node right = ConstantNode.INF;
03675: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03676: case RANGE:
03677: jj_consume_token(RANGE);
03678: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03679: case MODULE:
03680: case SYMBOL:
03681: case BEGIN:
03682: case DOT:
03683: case STAR:
03684: case IMPORT:
03685: case STRING_LITERAL:
03686: case FUNCTION:
03687: case OPEN:
03688: case SUPER:
03689: case STATIC:
03690: case CLASS:
03691: case VAR:
03692: case ET:
03693: case NEGATION:
03694: case PLUS:
03695: case MINUS:
03696: case MINUSMINUS:
03697: case PLUSPLUS:
03698: case COPYOF:
03699: case CLONEOF:
03700: case TYPEOF:
03701: case SIZEOF:
03702: case CLASSOF:
03703: case BOOLEAN:
03704: case INT:
03705: case FLOAT:
03706: case STRING:
03707: case DEFINED:
03708: case UNDEFINED:
03709: case NULL:
03710: case OPEN_BRACKET:
03711: case CARET:
03712: case DELETE:
03713: case BEGIN_LIST:
03714: case NEW:
03715: case THIS:
03716: case INTEGER_LITERAL:
03717: case FLOATING_POINT_LITERAL:
03718: case INF:
03719: case FALSE:
03720: case TRUE:
03721: case PATTERN:
03722: LogicalORExpression();
03723: right = pop();
03724: break;
03725: default:
03726: jj_la1[94] = jj_gen;
03727: ;
03728: }
03729: push(new RangeNode(ConstantNode.NEG_INF, right));
03730: break;
03731: case MODULE:
03732: case SYMBOL:
03733: case BEGIN:
03734: case DOT:
03735: case STAR:
03736: case IMPORT:
03737: case STRING_LITERAL:
03738: case FUNCTION:
03739: case OPEN:
03740: case SUPER:
03741: case STATIC:
03742: case CLASS:
03743: case VAR:
03744: case ET:
03745: case NEGATION:
03746: case PLUS:
03747: case MINUS:
03748: case MINUSMINUS:
03749: case PLUSPLUS:
03750: case COPYOF:
03751: case CLONEOF:
03752: case TYPEOF:
03753: case SIZEOF:
03754: case CLASSOF:
03755: case BOOLEAN:
03756: case INT:
03757: case FLOAT:
03758: case STRING:
03759: case DEFINED:
03760: case UNDEFINED:
03761: case NULL:
03762: case OPEN_BRACKET:
03763: case CARET:
03764: case DELETE:
03765: case BEGIN_LIST:
03766: case NEW:
03767: case THIS:
03768: case INTEGER_LITERAL:
03769: case FLOATING_POINT_LITERAL:
03770: case INF:
03771: case FALSE:
03772: case TRUE:
03773: case PATTERN:
03774: LogicalORExpression();
03775: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03776: case RANGE:
03777: jj_consume_token(RANGE);
03778: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03779: case MODULE:
03780: case SYMBOL:
03781: case BEGIN:
03782: case DOT:
03783: case STAR:
03784: case IMPORT:
03785: case STRING_LITERAL:
03786: case FUNCTION:
03787: case OPEN:
03788: case SUPER:
03789: case STATIC:
03790: case CLASS:
03791: case VAR:
03792: case ET:
03793: case NEGATION:
03794: case PLUS:
03795: case MINUS:
03796: case MINUSMINUS:
03797: case PLUSPLUS:
03798: case COPYOF:
03799: case CLONEOF:
03800: case TYPEOF:
03801: case SIZEOF:
03802: case CLASSOF:
03803: case BOOLEAN:
03804: case INT:
03805: case FLOAT:
03806: case STRING:
03807: case DEFINED:
03808: case UNDEFINED:
03809: case NULL:
03810: case OPEN_BRACKET:
03811: case CARET:
03812: case DELETE:
03813: case BEGIN_LIST:
03814: case NEW:
03815: case THIS:
03816: case INTEGER_LITERAL:
03817: case FLOATING_POINT_LITERAL:
03818: case INF:
03819: case FALSE:
03820: case TRUE:
03821: case PATTERN:
03822: LogicalORExpression();
03823: right = pop();
03824: break;
03825: default:
03826: jj_la1[95] = jj_gen;
03827: ;
03828: }
03829: push(new RangeNode(pop(), right));
03830: break;
03831: default:
03832: jj_la1[96] = jj_gen;
03833: ;
03834: }
03835: break;
03836: default:
03837: jj_la1[97] = jj_gen;
03838: jj_consume_token(-1);
03839: throw new ParseException();
03840: }
03841: }
03842:
03843: final public void LogicalORExpression() throws ParseException {
03844: LogicalXORExpression();
03845: label_34: while (true) {
03846: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03847: case BOOLEAN_OR:
03848: ;
03849: break;
03850: default:
03851: jj_la1[98] = jj_gen;
03852: break label_34;
03853: }
03854: jj_consume_token(BOOLEAN_OR);
03855: LogicalXORExpression();
03856: Node right = pop();
03857: Node left = pop();
03858: push(new OrNode(left, right));
03859: }
03860: }
03861:
03862: final public void LogicalXORExpression() throws ParseException {
03863: LogicalANDExpression();
03864: label_35: while (true) {
03865: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03866: case BOOLEAN_XOR:
03867: ;
03868: break;
03869: default:
03870: jj_la1[99] = jj_gen;
03871: break label_35;
03872: }
03873: jj_consume_token(BOOLEAN_XOR);
03874: LogicalANDExpression();
03875: Node right = pop();
03876: Node left = pop();
03877: push(new XorNode(left, right));
03878: }
03879: }
03880:
03881: final public void LogicalANDExpression() throws ParseException {
03882: EqualityExpression();
03883: label_36: while (true) {
03884: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03885: case BOOLEAN_AND:
03886: ;
03887: break;
03888: default:
03889: jj_la1[100] = jj_gen;
03890: break label_36;
03891: }
03892: jj_consume_token(BOOLEAN_AND);
03893: EqualityExpression();
03894: Node right = pop();
03895: Node left = pop();
03896: push(new AndNode(left, right));
03897: }
03898: }
03899:
03900: final public void EqualityExpression() throws ParseException {
03901: Token op;
03902: RelationalExpression();
03903: label_37: while (true) {
03904: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03905: case EQUAL:
03906: case NOT_EQUAL:
03907: case EXACT_EQUAL:
03908: case EXACT_NOT_EQUAL:
03909: case COMPARE:
03910: case EXACT_COMPARE:
03911: ;
03912: break;
03913: default:
03914: jj_la1[101] = jj_gen;
03915: break label_37;
03916: }
03917: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03918: case EQUAL:
03919: op = jj_consume_token(EQUAL);
03920: break;
03921: case NOT_EQUAL:
03922: op = jj_consume_token(NOT_EQUAL);
03923: break;
03924: case EXACT_EQUAL:
03925: op = jj_consume_token(EXACT_EQUAL);
03926: break;
03927: case EXACT_NOT_EQUAL:
03928: op = jj_consume_token(EXACT_NOT_EQUAL);
03929: break;
03930: case COMPARE:
03931: op = jj_consume_token(COMPARE);
03932: break;
03933: case EXACT_COMPARE:
03934: op = jj_consume_token(EXACT_COMPARE);
03935: break;
03936: default:
03937: jj_la1[102] = jj_gen;
03938: jj_consume_token(-1);
03939: throw new ParseException();
03940: }
03941: RelationalExpression();
03942: Node right = pop();
03943: Node left = pop();
03944: switch (op.kind) {
03945: case EQUAL:
03946: push(new EqualToNode(left, right));
03947: break;
03948: case NOT_EQUAL:
03949: push(new NotEqualToNode(left, right));
03950: break;
03951: case EXACT_EQUAL:
03952: push(new ExactEqualToNode(left, right));
03953: break;
03954: case EXACT_NOT_EQUAL:
03955: push(new ExactNotEqualToNode(left, right));
03956: break;
03957: case COMPARE:
03958: push(new CompareNode(left, right));
03959: break;
03960: case EXACT_COMPARE:
03961: push(new ExactCompareNode(left, right));
03962: break;
03963: }
03964: }
03965: }
03966:
03967: final public void RelationalExpression() throws ParseException {
03968: ArrayList ops = null;
03969: Token op;
03970: InExpression();
03971: label_38: while (true) {
03972: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03973: case LESS:
03974: case GREATER:
03975: case LESS_OR_EQUAL:
03976: case GREATER_OR_EQUAL:
03977: ;
03978: break;
03979: default:
03980: jj_la1[103] = jj_gen;
03981: break label_38;
03982: }
03983: if (ops == null) {
03984: ops = new ArrayList();
03985: }
03986: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03987: case LESS:
03988: op = jj_consume_token(LESS);
03989: break;
03990: case GREATER:
03991: op = jj_consume_token(GREATER);
03992: break;
03993: case LESS_OR_EQUAL:
03994: op = jj_consume_token(LESS_OR_EQUAL);
03995: break;
03996: case GREATER_OR_EQUAL:
03997: op = jj_consume_token(GREATER_OR_EQUAL);
03998: break;
03999: default:
04000: jj_la1[104] = jj_gen;
04001: jj_consume_token(-1);
04002: throw new ParseException();
04003: }
04004: ops.add(op);
04005: InExpression();
04006: }
04007: if (ops != null) {
04008: int n = ops.size() + 1;
04009: if (n > 2) {
04010: Node[] childs = new Node[n];
04011: int[] operators = new int[n - 1];
04012: for (int i = n - 1; i >= 0; i--) {
04013: childs[i] = pop();
04014: }
04015: for (int i = 0; i < n - 1; i++) {
04016: operators[i] = ((Token) ops.get(i)).kind;
04017: }
04018: push(new ChainedComparisonNode(childs, operators));
04019:
04020: } else {
04021: Node right = pop();
04022: Node left = pop();
04023: switch (((Token) ops.get(0)).kind) {
04024: case LESS:
04025: push(new LessThanNode(left, right));
04026: break;
04027: case GREATER:
04028: push(new GreaterThanNode(left, right));
04029: break;
04030: case LESS_OR_EQUAL:
04031: push(new LessThanOrEqualToNode(left, right));
04032: break;
04033: case GREATER_OR_EQUAL:
04034: push(new GreaterThanOrEqualToNode(left, right));
04035: break;
04036: }
04037: }
04038: }
04039: }
04040:
04041: final public void InExpression() throws ParseException {
04042: Token op;
04043: Token neg = null;
04044: AdditiveExpression();
04045: label_39: while (true) {
04046: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04047: case NEGATION:
04048: case IN:
04049: ;
04050: break;
04051: default:
04052: jj_la1[105] = jj_gen;
04053: break label_39;
04054: }
04055: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04056: case NEGATION:
04057: neg = jj_consume_token(NEGATION);
04058: break;
04059: default:
04060: jj_la1[106] = jj_gen;
04061: ;
04062: }
04063: op = jj_consume_token(IN);
04064: AdditiveExpression();
04065: Node right = pop();
04066: Node left = pop();
04067: if (neg != null) {
04068: push(new UnaryNegateNode(new InNode(left, right)));
04069: } else {
04070: push(new InNode(left, right));
04071: }
04072: }
04073: }
04074:
04075: final public void AdditiveExpression() throws ParseException {
04076: Token op;
04077: MultiplicativeExpression();
04078: label_40: while (true) {
04079: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04080: case ET:
04081: case PLUS:
04082: case MINUS:
04083: ;
04084: break;
04085: default:
04086: jj_la1[107] = jj_gen;
04087: break label_40;
04088: }
04089: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04090: case PLUS:
04091: op = jj_consume_token(PLUS);
04092: break;
04093: case MINUS:
04094: op = jj_consume_token(MINUS);
04095: break;
04096: case ET:
04097: op = jj_consume_token(ET);
04098: break;
04099: default:
04100: jj_la1[108] = jj_gen;
04101: jj_consume_token(-1);
04102: throw new ParseException();
04103: }
04104: MultiplicativeExpression();
04105: Node right = pop();
04106: Node left = pop();
04107: switch (op.kind) {
04108: case PLUS:
04109: push(new AdditionNode(left, right));
04110: break;
04111: case MINUS:
04112: push(new SubtractionNode(left, right));
04113: break;
04114: case ET:
04115: push(new ConcatenationNode(left, right));
04116: break;
04117: }
04118: }
04119: }
04120:
04121: final public void MultiplicativeExpression() throws ParseException {
04122: Token op;
04123: MatchExpression();
04124: label_41: while (true) {
04125: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04126: case STAR:
04127: case SLASH:
04128: case REMAINDER:
04129: ;
04130: break;
04131: default:
04132: jj_la1[109] = jj_gen;
04133: break label_41;
04134: }
04135: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04136: case STAR:
04137: op = jj_consume_token(STAR);
04138: break;
04139: case SLASH:
04140: op = jj_consume_token(SLASH);
04141: break;
04142: case REMAINDER:
04143: op = jj_consume_token(REMAINDER);
04144: break;
04145: default:
04146: jj_la1[110] = jj_gen;
04147: jj_consume_token(-1);
04148: throw new ParseException();
04149: }
04150: MatchExpression();
04151: Node right = pop();
04152: Node left = pop();
04153: switch (op.kind) {
04154: case STAR:
04155: push(new MultiplicationNode(left, right));
04156: break;
04157: case SLASH:
04158: push(new DivisionNode(left, right));
04159: break;
04160: case REMAINDER:
04161: push(new ModuloNode(left, right));
04162: break;
04163: }
04164: }
04165: }
04166:
04167: final public void MatchExpression() throws ParseException {
04168: Token op;
04169: UnaryExpression();
04170: label_42: while (true) {
04171: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04172: case MATCH:
04173: case NO_MATCH:
04174: ;
04175: break;
04176: default:
04177: jj_la1[111] = jj_gen;
04178: break label_42;
04179: }
04180: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04181: case MATCH:
04182: op = jj_consume_token(MATCH);
04183: break;
04184: case NO_MATCH:
04185: op = jj_consume_token(NO_MATCH);
04186: break;
04187: default:
04188: jj_la1[112] = jj_gen;
04189: jj_consume_token(-1);
04190: throw new ParseException();
04191: }
04192: UnaryExpression();
04193: Node right = pop();
04194: Node left = pop();
04195: switch (op.kind) {
04196: case MATCH:
04197: push(new MatchNode(left, right));
04198: break;
04199: case NO_MATCH:
04200: push(new NoMatchNode(left, right));
04201: break;
04202: }
04203: }
04204: }
04205:
04206: final public void UnaryExpression() throws ParseException {
04207: Token op;
04208: Token t;
04209: Node child;
04210: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04211: case NEGATION:
04212: jj_consume_token(NEGATION);
04213: UnaryExpression();
04214: push(new UnaryNegateNode(pop()));
04215: break;
04216: case PLUS:
04217: jj_consume_token(PLUS);
04218: UnaryExpression();
04219: push(new UnaryPlusNode(pop()));
04220: break;
04221: case MINUS:
04222: jj_consume_token(MINUS);
04223: UnaryExpression();
04224: String image = null;
04225: child = pop();
04226: if (child.typeOf() == Node.EXPR_CONSTANT) {
04227: image = ((ConstantNode) child).getImage();
04228: }
04229: if (image == null) {
04230: push(new UnaryMinusNode(child));
04231: } else {
04232: image = "-" + image;
04233: push(new ConstantNode(image, Conversions
04234: .parseNumber(image)));
04235: }
04236: break;
04237: case STAR:
04238: op = jj_consume_token(STAR);
04239: UnaryExpression();
04240: push(new EnumerationNode(pop()));
04241: break;
04242: case MINUSMINUS:
04243: op = jj_consume_token(MINUSMINUS);
04244: UnaryExpression();
04245: push(new PrefixDecrementNode(toLocation(op), pop()));
04246: break;
04247: case PLUSPLUS:
04248: op = jj_consume_token(PLUSPLUS);
04249: UnaryExpression();
04250: push(new PrefixIncrementNode(toLocation(op), pop()));
04251: break;
04252: case COPYOF:
04253: jj_consume_token(COPYOF);
04254: UnaryExpression();
04255: push(new CopyNode(pop()));
04256: break;
04257: case CLONEOF:
04258: jj_consume_token(CLONEOF);
04259: UnaryExpression();
04260: push(new CloneNode(pop()));
04261: break;
04262: case TYPEOF:
04263: jj_consume_token(TYPEOF);
04264: UnaryExpression();
04265: push(new TypeOfNode(pop()));
04266: break;
04267: case SIZEOF:
04268: jj_consume_token(SIZEOF);
04269: UnaryExpression();
04270: push(new SizeOfNode(pop()));
04271: break;
04272: case CLASSOF:
04273: jj_consume_token(CLASSOF);
04274: UnaryExpression();
04275: push(new ClassOfNode(pop()));
04276: break;
04277: default:
04278: jj_la1[114] = jj_gen;
04279: if (jj_2_16(2)) {
04280: jj_consume_token(OPEN);
04281: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04282: case BOOLEAN:
04283: op = jj_consume_token(BOOLEAN);
04284: break;
04285: case INT:
04286: op = jj_consume_token(INT);
04287: break;
04288: case FLOAT:
04289: op = jj_consume_token(FLOAT);
04290: break;
04291: case STRING:
04292: op = jj_consume_token(STRING);
04293: break;
04294: default:
04295: jj_la1[113] = jj_gen;
04296: jj_consume_token(-1);
04297: throw new ParseException();
04298: }
04299: jj_consume_token(CLOSE);
04300: UnaryExpression();
04301: switch (op.kind) {
04302: case BOOLEAN:
04303: push(new BooleanCastNode(pop()));
04304: break;
04305: case INT:
04306: push(new IntCastNode(pop()));
04307: break;
04308: case FLOAT:
04309: push(new FloatCastNode(pop()));
04310: break;
04311: case STRING:
04312: push(new StringCastNode(pop()));
04313: break;
04314: }
04315: } else {
04316: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04317: case MODULE:
04318: case SYMBOL:
04319: case BEGIN:
04320: case DOT:
04321: case IMPORT:
04322: case STRING_LITERAL:
04323: case FUNCTION:
04324: case OPEN:
04325: case SUPER:
04326: case STATIC:
04327: case CLASS:
04328: case VAR:
04329: case ET:
04330: case BOOLEAN:
04331: case INT:
04332: case FLOAT:
04333: case STRING:
04334: case DEFINED:
04335: case UNDEFINED:
04336: case NULL:
04337: case OPEN_BRACKET:
04338: case CARET:
04339: case DELETE:
04340: case BEGIN_LIST:
04341: case NEW:
04342: case THIS:
04343: case INTEGER_LITERAL:
04344: case FLOATING_POINT_LITERAL:
04345: case INF:
04346: case FALSE:
04347: case TRUE:
04348: case PATTERN:
04349: UnaryPostfixExpression();
04350: break;
04351: default:
04352: jj_la1[115] = jj_gen;
04353: jj_consume_token(-1);
04354: throw new ParseException();
04355: }
04356: }
04357: }
04358: }
04359:
04360: final public void UnaryPostfixExpression() throws ParseException {
04361: Token op;
04362: Node child;
04363: IsExpression();
04364: label_43: while (true) {
04365: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04366: case MINUSMINUS:
04367: case PLUSPLUS:
04368: ;
04369: break;
04370: default:
04371: jj_la1[116] = jj_gen;
04372: break label_43;
04373: }
04374: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04375: case PLUSPLUS:
04376: op = jj_consume_token(PLUSPLUS);
04377: push(new PostfixIncrementNode(toLocation(op), pop()));
04378: break;
04379: case MINUSMINUS:
04380: op = jj_consume_token(MINUSMINUS);
04381: push(new PostfixDecrementNode(toLocation(op), pop()));
04382: break;
04383: default:
04384: jj_la1[117] = jj_gen;
04385: jj_consume_token(-1);
04386: throw new ParseException();
04387: }
04388: }
04389: }
04390:
04391: final public void IsExpression() throws ParseException {
04392: Token t;
04393: Name name;
04394: boolean not = false;
04395: LazyExpression();
04396: label_44: while (true) {
04397: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04398: case IS:
04399: case HAS:
04400: ;
04401: break;
04402: default:
04403: jj_la1[118] = jj_gen;
04404: break label_44;
04405: }
04406: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04407: case IS:
04408: t = jj_consume_token(IS);
04409: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04410: case NEGATION:
04411: jj_consume_token(NEGATION);
04412: not = true;
04413: break;
04414: default:
04415: jj_la1[119] = jj_gen;
04416: ;
04417: }
04418: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04419: case DEFINED:
04420: jj_consume_token(DEFINED);
04421: push(new IsNode(pop(), IsNode.IS_DEFINED));
04422: break;
04423: case UNDEFINED:
04424: jj_consume_token(UNDEFINED);
04425: push(new IsNode(pop(), IsNode.IS_UNDEFINED));
04426: break;
04427: case NULL:
04428: jj_consume_token(NULL);
04429: push(new IsNode(pop(), Any.IS_NULL));
04430: break;
04431: case BOOLEAN:
04432: jj_consume_token(BOOLEAN);
04433: push(new IsNode(pop(), Any.IS_BOOLEAN));
04434: break;
04435: case INT:
04436: jj_consume_token(INT);
04437: push(new IsNode(pop(), Any.IS_INT));
04438: break;
04439: case FLOAT:
04440: jj_consume_token(FLOAT);
04441: push(new IsNode(pop(), Any.IS_DOUBLE));
04442: break;
04443: case STRING:
04444: jj_consume_token(STRING);
04445: push(new IsNode(pop(), Any.IS_STRING));
04446: break;
04447: case RANGE:
04448: jj_consume_token(RANGE);
04449: push(new IsNode(pop(), Any.IS_RANGE));
04450: break;
04451: case MAP:
04452: jj_consume_token(MAP);
04453: push(new IsNode(pop(), Any.IS_MAP));
04454: break;
04455: case OPEN:
04456: jj_consume_token(OPEN);
04457: jj_consume_token(CLOSE);
04458: push(new IsNode(pop(), Any.IS_TUPLE));
04459: break;
04460: case BEGIN:
04461: jj_consume_token(BEGIN);
04462: jj_consume_token(END);
04463: push(new IsNode(pop(), Any.IS_LIST));
04464: break;
04465: case OPEN_BRACKET:
04466: jj_consume_token(OPEN_BRACKET);
04467: jj_consume_token(CLOSE_BRACKET);
04468: push(new IsNode(pop(), Any.IS_ARRAY));
04469: break;
04470: case CLASS:
04471: jj_consume_token(CLASS);
04472: push(new IsNode(pop(), Any.IS_CLASS));
04473: break;
04474: case ET:
04475: jj_consume_token(ET);
04476: push(new IsNode(pop(), Any.IS_REF));
04477: break;
04478: case MODULE:
04479: case SYMBOL:
04480: name = Name(null);
04481: Location location = toLocation(t);
04482: LinkNode link = new LinkNode(flowPeek(), location,
04483: name, null, LinkNode.GET);
04484: push(new InstanceOfNode(pop(), link, location));
04485: break;
04486: default:
04487: jj_la1[120] = jj_gen;
04488: jj_consume_token(-1);
04489: throw new ParseException();
04490: }
04491: if (not) {
04492: push(new UnaryNegateNode(pop()));
04493: not = false;
04494: }
04495: break;
04496: case HAS:
04497: jj_consume_token(HAS);
04498: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04499: case NEGATION:
04500: jj_consume_token(NEGATION);
04501: not = true;
04502: break;
04503: default:
04504: jj_la1[121] = jj_gen;
04505: ;
04506: }
04507: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04508: case SYMBOL:
04509: t = jj_consume_token(SYMBOL);
04510: push(new HasNode(pop(), t.image));
04511: break;
04512: case OPEN:
04513: jj_consume_token(OPEN);
04514: ExpressionStart();
04515: jj_consume_token(CLOSE);
04516: Node right = pop();
04517: Node left = pop();
04518: push(new DynamicHasNode(left, right));
04519: break;
04520: default:
04521: jj_la1[122] = jj_gen;
04522: jj_consume_token(-1);
04523: throw new ParseException();
04524: }
04525: if (not) {
04526: push(new UnaryNegateNode(pop()));
04527: not = false;
04528: }
04529: break;
04530: default:
04531: jj_la1[123] = jj_gen;
04532: jj_consume_token(-1);
04533: throw new ParseException();
04534: }
04535: }
04536: }
04537:
04538: final public void LazyExpression() throws ParseException {
04539: Token op = null;
04540: Location location = null;
04541: FunctionStatement thunk = null;
04542: FunctionStatement context = null;
04543: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04544: case CARET:
04545: op = jj_consume_token(CARET);
04546: location = toLocation(op);
04547: Statement stmt = flowPeek();
04548: DefinitionStatement parent = stmt.getScopeStatement();
04549: context = stmt.getFunctionStatement();
04550: String name = "thunk$" + parent.getNextInlined();
04551: if (parent.typeOf() == Statement.ST_CLASS) {
04552: thunk = new MethodStatement(location, parent, context,
04553: false, name, null,
04554: ParameterListDeclaration.EMPTY);
04555: } else {
04556: thunk = new FunctionStatement(location, parent,
04557: context, false, name, null,
04558: ParameterListDeclaration.EMPTY);
04559: }
04560: thunk.setParentStatement(flowPeek());
04561: parent.declare(thunk);
04562: flowPush(thunk);
04563: flowPush(thunk.getChildStatement());
04564: break;
04565: default:
04566: jj_la1[124] = jj_gen;
04567: ;
04568: }
04569: PrimaryExpression();
04570: if (op != null) {
04571: Expression expr = new Expression(pop(), location);
04572: EvalStatement evalstmt = new EvalStatement(thunk, location,
04573: expr);
04574: thunk.addChild(evalstmt);
04575: push(new ThunkNode(context, thunk));
04576: flowPop();
04577: flowPop();
04578: }
04579: }
04580:
04581: final public void PrimaryExpression() throws ParseException {
04582: Token op;
04583: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04584: case STRING_LITERAL:
04585: case UNDEFINED:
04586: case NULL:
04587: case INTEGER_LITERAL:
04588: case FLOATING_POINT_LITERAL:
04589: case INF:
04590: case FALSE:
04591: case TRUE:
04592: case PATTERN:
04593: Constant();
04594: ObjectConstruct(LinkNode.GET);
04595: break;
04596: case IMPORT:
04597: jj_consume_token(IMPORT);
04598: jj_consume_token(OPEN);
04599: ExpressionStart();
04600: jj_consume_token(CLOSE);
04601: push(new ImportNode(pop()));
04602: ObjectConstruct(LinkNode.GET);
04603: break;
04604: case DEFINED:
04605: jj_consume_token(DEFINED);
04606: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04607: case OPEN:
04608: jj_consume_token(OPEN);
04609: Symbol(LinkNode.GET);
04610: jj_consume_token(CLOSE);
04611: break;
04612: case MODULE:
04613: case SYMBOL:
04614: case DOT:
04615: case FUNCTION:
04616: case SUPER:
04617: case STATIC:
04618: case CLASS:
04619: case VAR:
04620: case THIS:
04621: Symbol(LinkNode.GET);
04622: break;
04623: default:
04624: jj_la1[125] = jj_gen;
04625: jj_consume_token(-1);
04626: throw new ParseException();
04627: }
04628: push(new DefinedNode(pop()));
04629: break;
04630: case DELETE:
04631: op = jj_consume_token(DELETE);
04632: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04633: case OPEN:
04634: jj_consume_token(OPEN);
04635: Symbol(LinkNode.GET);
04636: jj_consume_token(CLOSE);
04637: break;
04638: case MODULE:
04639: case SYMBOL:
04640: case DOT:
04641: case FUNCTION:
04642: case SUPER:
04643: case STATIC:
04644: case CLASS:
04645: case VAR:
04646: case THIS:
04647: Symbol(LinkNode.GET);
04648: break;
04649: default:
04650: jj_la1[126] = jj_gen;
04651: jj_consume_token(-1);
04652: throw new ParseException();
04653: }
04654: Node child = pop();
04655: switch (child.typeOf()) {
04656: case Node.EXPR_VARIABLE:
04657: error(toLocation(op), "Cannot delete variables");
04658: break;
04659: case Node.EXPR_INVOKE:
04660: error(toLocation(op), "Cannot delete methods");
04661: break;
04662: case Node.EXPR_CALL:
04663: error(toLocation(op), "Cannot delete functions");
04664: break;
04665: }
04666: push(new DeleteNode(child));
04667: break;
04668: default:
04669: jj_la1[128] = jj_gen;
04670: if (jj_2_17(2)) {
04671: jj_consume_token(OPEN);
04672: jj_consume_token(CLOSE);
04673: push(new ExpressionList(0));
04674: ObjectConstruct(LinkNode.GET);
04675: } else {
04676: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04677: case OPEN:
04678: jj_consume_token(OPEN);
04679: List(false, false);
04680: jj_consume_token(CLOSE);
04681: ObjectConstruct(LinkNode.GET);
04682: break;
04683: default:
04684: jj_la1[129] = jj_gen;
04685: if (jj_2_18(2)) {
04686: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04687: case BEGIN_LIST:
04688: jj_consume_token(BEGIN_LIST);
04689: break;
04690: case BEGIN:
04691: jj_consume_token(BEGIN);
04692: break;
04693: default:
04694: jj_la1[127] = jj_gen;
04695: jj_consume_token(-1);
04696: throw new ParseException();
04697: }
04698: jj_consume_token(END);
04699: push(new MutableExpressionList(0));
04700: ObjectConstruct(LinkNode.GET);
04701: } else {
04702: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04703: case OPEN_BRACKET:
04704: ArrayExpression();
04705: ObjectConstruct(LinkNode.GET);
04706: break;
04707: case NEW:
04708: NewConstruct();
04709: ObjectConstruct(LinkNode.GET);
04710: break;
04711: default:
04712: jj_la1[130] = jj_gen;
04713: if (jj_2_19(2147483647)) {
04714: InlineFunction();
04715: ObjectConstruct(LinkNode.GET);
04716: } else {
04717: switch ((jj_ntk == -1) ? jj_ntk()
04718: : jj_ntk) {
04719: case BEGIN:
04720: case BEGIN_LIST:
04721: ListConstruct();
04722: ObjectConstruct(LinkNode.GET);
04723: break;
04724: case BOOLEAN:
04725: jj_consume_token(BOOLEAN);
04726: push(new TypeNode(
04727: anvil.core.AnyBoolean.__class__));
04728: ObjectConstruct(LinkNode.GET);
04729: break;
04730: case INT:
04731: jj_consume_token(INT);
04732: push(new TypeNode(
04733: anvil.core.AnyInt.__class__));
04734: ObjectConstruct(LinkNode.GET);
04735: break;
04736: case FLOAT:
04737: jj_consume_token(FLOAT);
04738: push(new TypeNode(
04739: anvil.core.AnyDouble.__class__));
04740: ObjectConstruct(LinkNode.GET);
04741: break;
04742: case STRING:
04743: jj_consume_token(STRING);
04744: push(new TypeNode(
04745: anvil.core.AnyString.__class__));
04746: ObjectConstruct(LinkNode.GET);
04747: break;
04748: case ET:
04749: op = jj_consume_token(ET);
04750: Symbol(LinkNode.GET);
04751: push(new RefNode(toLocation(op),
04752: pop(), false));
04753: break;
04754: case MODULE:
04755: case SYMBOL:
04756: case DOT:
04757: case FUNCTION:
04758: case SUPER:
04759: case STATIC:
04760: case CLASS:
04761: case VAR:
04762: case THIS:
04763: Symbol(LinkNode.GET);
04764: break;
04765: default:
04766: jj_la1[131] = jj_gen;
04767: jj_consume_token(-1);
04768: throw new ParseException();
04769: }
04770: }
04771: }
04772: }
04773: }
04774: }
04775: }
04776: }
04777:
04778: final public void NewConstruct() throws ParseException {
04779: Token t;
04780: Location location;
04781: Name name = new Name();
04782: t = jj_consume_token(NEW);
04783: location = toLocation(t);
04784: name.add(t);
04785: Name(name);
04786: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04787: case OPEN:
04788: jj_consume_token(OPEN);
04789: ArgumentList();
04790: jj_consume_token(CLOSE);
04791: break;
04792: case BEGIN:
04793: InlineFunction();
04794: push(new ExpressionList(pop()));
04795: break;
04796: default:
04797: jj_la1[132] = jj_gen;
04798: jj_consume_token(-1);
04799: throw new ParseException();
04800: }
04801: push(new LinkNode(flowPeek(), location, name, (Parent) pop(),
04802: LinkNode.NEW));
04803: }
04804:
04805: final public Token DotAndThisOrSymbol() throws ParseException {
04806: Token t;
04807: jj_consume_token(DOT);
04808: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04809: case THIS:
04810: t = jj_consume_token(THIS);
04811: break;
04812: case SYMBOL:
04813: t = jj_consume_token(SYMBOL);
04814: break;
04815: default:
04816: jj_la1[133] = jj_gen;
04817: jj_consume_token(-1);
04818: throw new ParseException();
04819: }
04820: {
04821: if (true)
04822: return t;
04823: }
04824: throw new Error("Missing return statement in function");
04825: }
04826:
04827: final public void Symbol(int role) throws ParseException {
04828: Token t;
04829: Token var = null;
04830: Location location;
04831: Parent args = null;
04832: Name name = new Name();
04833: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04834: case MODULE:
04835: case SYMBOL:
04836: case FUNCTION:
04837: case SUPER:
04838: case STATIC:
04839: case CLASS:
04840: case VAR:
04841: case THIS:
04842: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04843: case SYMBOL:
04844: case VAR:
04845: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04846: case VAR:
04847: var = jj_consume_token(VAR);
04848: break;
04849: default:
04850: jj_la1[134] = jj_gen;
04851: ;
04852: }
04853: t = jj_consume_token(SYMBOL);
04854: break;
04855: case MODULE:
04856: t = jj_consume_token(MODULE);
04857: break;
04858: case CLASS:
04859: t = jj_consume_token(CLASS);
04860: break;
04861: case STATIC:
04862: t = jj_consume_token(STATIC);
04863: break;
04864: case THIS:
04865: t = jj_consume_token(THIS);
04866: break;
04867: case SUPER:
04868: t = jj_consume_token(SUPER);
04869: break;
04870: case FUNCTION:
04871: t = jj_consume_token(FUNCTION);
04872: break;
04873: default:
04874: jj_la1[135] = jj_gen;
04875: jj_consume_token(-1);
04876: throw new ParseException();
04877: }
04878: location = toLocation(var != null ? var : t);
04879:
04880: if (var != null) {
04881: Statement stmt = flowPeek();
04882: if (stmt.isStaticRegion()
04883: && stmt.getFunctionStatement() == null) {
04884: error(
04885: location,
04886: "Explicit variable declaration modifier 'var' cannot be used in static initialization");
04887: } else {
04888: switch (role) {
04889: case LinkNode.ASSIGN:
04890: case LinkNode.GET:
04891: case LinkNode.DECLARE:
04892: role = LinkNode.DECLARE;
04893: break;
04894: default:
04895: error(location,
04896: "Invalid use of explicit variable declaration modifier 'var'");
04897: }
04898: }
04899: }
04900:
04901: name.add(t);
04902: label_45: while (true) {
04903: if (jj_2_20(2147483647)) {
04904: ;
04905: } else {
04906: break label_45;
04907: }
04908: t = DotAndThisOrSymbol();
04909: name.add(t);
04910: }
04911: break;
04912: case DOT:
04913: t = jj_consume_token(DOT);
04914: location = toLocation(t);
04915: name.add(t);
04916: t = jj_consume_token(SYMBOL);
04917: name.add(t);
04918: label_46: while (true) {
04919: if (jj_2_21(2147483647)) {
04920: ;
04921: } else {
04922: break label_46;
04923: }
04924: t = DotAndThisOrSymbol();
04925: name.add(t);
04926: }
04927: break;
04928: default:
04929: jj_la1[136] = jj_gen;
04930: jj_consume_token(-1);
04931: throw new ParseException();
04932: }
04933: if (jj_2_22(2147483647)) {
04934: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04935: case OPEN:
04936: jj_consume_token(OPEN);
04937: ArgumentList();
04938: jj_consume_token(CLOSE);
04939: args = (Parent) pop();
04940: break;
04941: case BEGIN:
04942: InlineFunction();
04943: args = new ExpressionList(pop());
04944: break;
04945: default:
04946: jj_la1[137] = jj_gen;
04947: jj_consume_token(-1);
04948: throw new ParseException();
04949: }
04950: } else {
04951: ;
04952: }
04953: push(new LinkNode(flowPeek(), location, name, args, role));
04954: ObjectConstruct(role);
04955: }
04956:
04957: final public void ObjectConstruct(int role) throws ParseException {
04958: Token t;
04959: boolean terminated = false;
04960: boolean isMethod;
04961: Parent parameters;
04962: label_47: while (true) {
04963: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04964: case BEGIN:
04965: case DOT:
04966: case OPEN:
04967: case OPEN_BRACKET:
04968: ;
04969: break;
04970: default:
04971: jj_la1[138] = jj_gen;
04972: break label_47;
04973: }
04974: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04975: case OPEN:
04976: t = jj_consume_token(OPEN);
04977: ArgumentList();
04978: jj_consume_token(CLOSE);
04979: parameters = (Parent) pop();
04980: if (parameters.hasNamedParameters()) {
04981: error(toLocation(t),
04982: "Named parameters are ignored in anonymous calls");
04983: }
04984: push(new DynamicCallNode(pop(), parameters));
04985: break;
04986: case BEGIN:
04987: InlineFunction();
04988: parameters = new ExpressionList(pop());
04989: push(new DynamicCallNode(pop(), parameters));
04990: break;
04991: case DOT:
04992: jj_consume_token(DOT);
04993: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04994: case OPEN:
04995: t = jj_consume_token(OPEN);
04996: ExpressionStart();
04997: jj_consume_token(CLOSE);
04998: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04999: case OPEN:
05000: jj_consume_token(OPEN);
05001: ArgumentList();
05002: jj_consume_token(CLOSE);
05003: break;
05004: case BEGIN:
05005: InlineFunction();
05006: push(new ExpressionList(pop()));
05007: break;
05008: default:
05009: jj_la1[139] = jj_gen;
05010: jj_consume_token(-1);
05011: throw new ParseException();
05012: }
05013: if (terminated) {
05014: error(toLocation(t),
05015: "Empty brackets terminate variable expression");
05016: }
05017: parameters = (Parent) pop();
05018: if (parameters.hasNamedParameters()) {
05019: error(toLocation(t),
05020: "Named parameters are ignored in anonymous invokes");
05021: }
05022: Node method = pop();
05023: Node self = pop();
05024: push(new DynamicInvokeNode(self, method, parameters));
05025: break;
05026: case SYMBOL:
05027: t = jj_consume_token(SYMBOL);
05028: isMethod = false;
05029: if (jj_2_23(2)) {
05030: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05031: case OPEN:
05032: jj_consume_token(OPEN);
05033: ArgumentList();
05034: jj_consume_token(CLOSE);
05035: break;
05036: case BEGIN:
05037: InlineFunction();
05038: push(new ExpressionList(pop()));
05039: break;
05040: default:
05041: jj_la1[140] = jj_gen;
05042: jj_consume_token(-1);
05043: throw new ParseException();
05044: }
05045: isMethod = true;
05046: } else {
05047: ;
05048: }
05049: if (terminated) {
05050: error(toLocation(t),
05051: "Empty brackets terminate variable expression");
05052: }
05053: if (isMethod) {
05054: parameters = (Parent) pop();
05055: if (parameters.hasNamedParameters()) {
05056: error(toLocation(t),
05057: "Named parameters are ignored in anonymous invokes");
05058: }
05059: push(new InvokeNode(pop(), t.image, parameters));
05060: } else {
05061: push(new AttributeNode(pop(), t.image));
05062: }
05063: break;
05064: case CLASS:
05065: jj_consume_token(CLASS);
05066: push(new ClassOfNode(pop()));
05067: break;
05068: case SIZEOF:
05069: jj_consume_token(SIZEOF);
05070: push(new SizeOfNode(pop()));
05071: break;
05072: case TYPEOF:
05073: jj_consume_token(TYPEOF);
05074: push(new TypeOfNode(pop()));
05075: break;
05076: case CLONEOF:
05077: jj_consume_token(CLONEOF);
05078: push(new CloneNode(pop()));
05079: break;
05080: case COPYOF:
05081: jj_consume_token(COPYOF);
05082: push(new CopyNode(pop()));
05083: break;
05084: default:
05085: jj_la1[141] = jj_gen;
05086: jj_consume_token(-1);
05087: throw new ParseException();
05088: }
05089: break;
05090: default:
05091: jj_la1[142] = jj_gen;
05092: if (jj_2_24(2)) {
05093: t = jj_consume_token(OPEN_BRACKET);
05094: List(false, false);
05095: jj_consume_token(CLOSE_BRACKET);
05096: if (terminated) {
05097: error(toLocation(t),
05098: "Empty brackets terminate variable expression");
05099: }
05100: Node expression = pop();
05101: Node self = pop();
05102: push(new ReferenceNode(self, expression));
05103: } else {
05104: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05105: case OPEN_BRACKET:
05106: t = jj_consume_token(OPEN_BRACKET);
05107: jj_consume_token(CLOSE_BRACKET);
05108: if (role != LinkNode.ASSIGN) {
05109: error(toLocation(t),
05110: "Empty brackets may only be used on assignments");
05111: }
05112: terminated = true;
05113: push(new EmptyReferenceNode(pop()));
05114: break;
05115: default:
05116: jj_la1[143] = jj_gen;
05117: jj_consume_token(-1);
05118: throw new ParseException();
05119: }
05120: }
05121: }
05122: }
05123: }
05124:
05125: final public void Comprehension(ComprehensionNode compr,
05126: Statement root, Statement parent) throws ParseException {
05127: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05128: case IF:
05129: ComprehensionIf(compr, root, parent);
05130: break;
05131: case FOREACH:
05132: ComprehensionForeach(compr, root, parent);
05133: break;
05134: case MODULE:
05135: case SYMBOL:
05136: case BEGIN:
05137: case DOT:
05138: case STAR:
05139: case IMPORT:
05140: case STRING_LITERAL:
05141: case RANGE:
05142: case FUNCTION:
05143: case OPEN:
05144: case SUPER:
05145: case STATIC:
05146: case CLASS:
05147: case VAR:
05148: case ET:
05149: case NEGATION:
05150: case PLUS:
05151: case MINUS:
05152: case MINUSMINUS:
05153: case PLUSPLUS:
05154: case COPYOF:
05155: case CLONEOF:
05156: case TYPEOF:
05157: case SIZEOF:
05158: case CLASSOF:
05159: case BOOLEAN:
05160: case INT:
05161: case FLOAT:
05162: case STRING:
05163: case DEFINED:
05164: case UNDEFINED:
05165: case NULL:
05166: case OPEN_BRACKET:
05167: case CARET:
05168: case DELETE:
05169: case BEGIN_LIST:
05170: case NEW:
05171: case THIS:
05172: case INTEGER_LITERAL:
05173: case FLOATING_POINT_LITERAL:
05174: case INF:
05175: case FALSE:
05176: case TRUE:
05177: case PATTERN:
05178: ArrayArgument();
05179: FunctionStatement function = flowPeek()
05180: .getFunctionStatement();
05181: VariableNode var = new VariableNode(function
05182: .declare("array$" + root.hashCode()));
05183: Location location = parent.getLocation();
05184: AssignmentNode assign = new AssignmentNode(location, 2);
05185: assign.setChild(0, new EmptyReferenceNode(var));
05186: assign.setChild(1, pop());
05187: parent.setChildStatement(new EvalStatement(parent,
05188: location, new Expression(assign, location)));
05189: compr.init(root, var);
05190: break;
05191: default:
05192: jj_la1[144] = jj_gen;
05193: jj_consume_token(-1);
05194: throw new ParseException();
05195: }
05196: }
05197:
05198: final public void ComprehensionForeach(ComprehensionNode compr,
05199: Statement root, Statement parent) throws ParseException {
05200: Statement stmt = null;
05201: stmt = ForeachStatementHeader(parent, null);
05202: parent.setChildStatement(stmt);
05203: if (root == null) {
05204: root = stmt;
05205: }
05206: Comprehension(compr, root, stmt);
05207: }
05208:
05209: final public void ComprehensionIf(ComprehensionNode compr,
05210: Statement root, Statement parent) throws ParseException {
05211: Token t;
05212: Statement stmt = null;
05213: t = jj_consume_token(IF);
05214: jj_consume_token(OPEN);
05215: Expression();
05216: jj_consume_token(CLOSE);
05217: stmt = new IfStatement(parent, toLocation(t),
05218: (Expression) pop());
05219: parent.setChildStatement(stmt);
05220: Comprehension(compr, root, stmt);
05221: }
05222:
05223: final public void ListConstruct() throws ParseException {
05224: ComprehensionNode node = null;
05225: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05226: case BEGIN:
05227: jj_consume_token(BEGIN);
05228: break;
05229: case BEGIN_LIST:
05230: jj_consume_token(BEGIN_LIST);
05231: break;
05232: default:
05233: jj_la1[145] = jj_gen;
05234: jj_consume_token(-1);
05235: throw new ParseException();
05236: }
05237: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05238: case FOREACH:
05239: node = new ListComprehensionNode();
05240: ComprehensionForeach(node, null, flowPeek());
05241: push(node);
05242: break;
05243: case MODULE:
05244: case SYMBOL:
05245: case BEGIN:
05246: case DOT:
05247: case STAR:
05248: case IMPORT:
05249: case STRING_LITERAL:
05250: case RANGE:
05251: case FUNCTION:
05252: case OPEN:
05253: case SUPER:
05254: case STATIC:
05255: case CLASS:
05256: case VAR:
05257: case ET:
05258: case NEGATION:
05259: case PLUS:
05260: case MINUS:
05261: case MINUSMINUS:
05262: case PLUSPLUS:
05263: case COPYOF:
05264: case CLONEOF:
05265: case TYPEOF:
05266: case SIZEOF:
05267: case CLASSOF:
05268: case BOOLEAN:
05269: case INT:
05270: case FLOAT:
05271: case STRING:
05272: case DEFINED:
05273: case UNDEFINED:
05274: case NULL:
05275: case OPEN_BRACKET:
05276: case CARET:
05277: case DELETE:
05278: case BEGIN_LIST:
05279: case NEW:
05280: case THIS:
05281: case INTEGER_LITERAL:
05282: case FLOATING_POINT_LITERAL:
05283: case INF:
05284: case FALSE:
05285: case TRUE:
05286: case PATTERN:
05287: List(true, true);
05288: break;
05289: default:
05290: jj_la1[146] = jj_gen;
05291: jj_consume_token(-1);
05292: throw new ParseException();
05293: }
05294: jj_consume_token(END);
05295: }
05296:
05297: final public void ArrayExpression() throws ParseException {
05298: Token t;
05299: int argc = 0;
05300: ComprehensionNode node = null;
05301: t = jj_consume_token(OPEN_BRACKET);
05302: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05303: case MODULE:
05304: case SYMBOL:
05305: case BEGIN:
05306: case DOT:
05307: case STAR:
05308: case IMPORT:
05309: case STRING_LITERAL:
05310: case RANGE:
05311: case FUNCTION:
05312: case OPEN:
05313: case SUPER:
05314: case STATIC:
05315: case CLASS:
05316: case VAR:
05317: case FOREACH:
05318: case ET:
05319: case NEGATION:
05320: case PLUS:
05321: case MINUS:
05322: case MINUSMINUS:
05323: case PLUSPLUS:
05324: case COPYOF:
05325: case CLONEOF:
05326: case TYPEOF:
05327: case SIZEOF:
05328: case CLASSOF:
05329: case BOOLEAN:
05330: case INT:
05331: case FLOAT:
05332: case STRING:
05333: case DEFINED:
05334: case UNDEFINED:
05335: case NULL:
05336: case OPEN_BRACKET:
05337: case CARET:
05338: case DELETE:
05339: case BEGIN_LIST:
05340: case NEW:
05341: case THIS:
05342: case INTEGER_LITERAL:
05343: case FLOATING_POINT_LITERAL:
05344: case INF:
05345: case FALSE:
05346: case TRUE:
05347: case PATTERN:
05348: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05349: case FOREACH:
05350: node = new ArrayComprehensionNode();
05351: ComprehensionForeach(node, null, flowPeek());
05352: break;
05353: case MODULE:
05354: case SYMBOL:
05355: case BEGIN:
05356: case DOT:
05357: case STAR:
05358: case IMPORT:
05359: case STRING_LITERAL:
05360: case RANGE:
05361: case FUNCTION:
05362: case OPEN:
05363: case SUPER:
05364: case STATIC:
05365: case CLASS:
05366: case VAR:
05367: case ET:
05368: case NEGATION:
05369: case PLUS:
05370: case MINUS:
05371: case MINUSMINUS:
05372: case PLUSPLUS:
05373: case COPYOF:
05374: case CLONEOF:
05375: case TYPEOF:
05376: case SIZEOF:
05377: case CLASSOF:
05378: case BOOLEAN:
05379: case INT:
05380: case FLOAT:
05381: case STRING:
05382: case DEFINED:
05383: case UNDEFINED:
05384: case NULL:
05385: case OPEN_BRACKET:
05386: case CARET:
05387: case DELETE:
05388: case BEGIN_LIST:
05389: case NEW:
05390: case THIS:
05391: case INTEGER_LITERAL:
05392: case FLOATING_POINT_LITERAL:
05393: case INF:
05394: case FALSE:
05395: case TRUE:
05396: case PATTERN:
05397: ArrayArgument();
05398: argc++;
05399: label_48: while (true) {
05400: if (jj_2_25(2)) {
05401: ;
05402: } else {
05403: break label_48;
05404: }
05405: jj_consume_token(COMMA);
05406: ArrayArgument();
05407: argc++;
05408: }
05409: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05410: case COMMA:
05411: jj_consume_token(COMMA);
05412: break;
05413: default:
05414: jj_la1[147] = jj_gen;
05415: ;
05416: }
05417: break;
05418: default:
05419: jj_la1[148] = jj_gen;
05420: jj_consume_token(-1);
05421: throw new ParseException();
05422: }
05423: break;
05424: default:
05425: jj_la1[149] = jj_gen;
05426: ;
05427: }
05428: jj_consume_token(CLOSE_BRACKET);
05429: if (node != null) {
05430: push(node);
05431: } else {
05432: Parent argv = new ExpressionList(argc);
05433: for (--argc; argc >= 0; argc--) {
05434: argv.setChild(argc, pop());
05435: }
05436: push(new ArrayNode(argv));
05437: }
05438: }
05439:
05440: final public void ArrayArgument() throws ParseException {
05441: Token symbol = null;
05442: if (jj_2_26(2)) {
05443: symbol = jj_consume_token(SYMBOL);
05444: jj_consume_token(ASSIGN);
05445: ExpressionStart();
05446: } else {
05447: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05448: case MODULE:
05449: case SYMBOL:
05450: case BEGIN:
05451: case DOT:
05452: case STAR:
05453: case IMPORT:
05454: case STRING_LITERAL:
05455: case RANGE:
05456: case FUNCTION:
05457: case OPEN:
05458: case SUPER:
05459: case STATIC:
05460: case CLASS:
05461: case VAR:
05462: case ET:
05463: case NEGATION:
05464: case PLUS:
05465: case MINUS:
05466: case MINUSMINUS:
05467: case PLUSPLUS:
05468: case COPYOF:
05469: case CLONEOF:
05470: case TYPEOF:
05471: case SIZEOF:
05472: case CLASSOF:
05473: case BOOLEAN:
05474: case INT:
05475: case FLOAT:
05476: case STRING:
05477: case DEFINED:
05478: case UNDEFINED:
05479: case NULL:
05480: case OPEN_BRACKET:
05481: case CARET:
05482: case DELETE:
05483: case BEGIN_LIST:
05484: case NEW:
05485: case THIS:
05486: case INTEGER_LITERAL:
05487: case FLOATING_POINT_LITERAL:
05488: case INF:
05489: case FALSE:
05490: case TRUE:
05491: case PATTERN:
05492: ExpressionStart();
05493: break;
05494: default:
05495: jj_la1[150] = jj_gen;
05496: jj_consume_token(-1);
05497: throw new ParseException();
05498: }
05499: }
05500: if (symbol != null) {
05501: push(new MappingNode(new SymbolNode(symbol.image), pop()));
05502: }
05503: }
05504:
05505: final public void OneArgument() throws ParseException {
05506: Token named = null;
05507: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05508: case AT:
05509: jj_consume_token(AT);
05510: ExpressionStart();
05511: push(new SpliceNode(pop()));
05512: break;
05513: default:
05514: jj_la1[151] = jj_gen;
05515: if (jj_2_27(2)) {
05516: named = jj_consume_token(SYMBOL);
05517: jj_consume_token(ASSIGN);
05518: ExpressionStart();
05519: push(new NamedNode(pop(), named.image));
05520: } else {
05521: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05522: case MODULE:
05523: case SYMBOL:
05524: case BEGIN:
05525: case DOT:
05526: case STAR:
05527: case IMPORT:
05528: case STRING_LITERAL:
05529: case RANGE:
05530: case FUNCTION:
05531: case OPEN:
05532: case SUPER:
05533: case STATIC:
05534: case CLASS:
05535: case VAR:
05536: case ET:
05537: case NEGATION:
05538: case PLUS:
05539: case MINUS:
05540: case MINUSMINUS:
05541: case PLUSPLUS:
05542: case COPYOF:
05543: case CLONEOF:
05544: case TYPEOF:
05545: case SIZEOF:
05546: case CLASSOF:
05547: case BOOLEAN:
05548: case INT:
05549: case FLOAT:
05550: case STRING:
05551: case DEFINED:
05552: case UNDEFINED:
05553: case NULL:
05554: case OPEN_BRACKET:
05555: case CARET:
05556: case DELETE:
05557: case BEGIN_LIST:
05558: case NEW:
05559: case THIS:
05560: case INTEGER_LITERAL:
05561: case FLOATING_POINT_LITERAL:
05562: case INF:
05563: case FALSE:
05564: case TRUE:
05565: case PATTERN:
05566: ExpressionStart();
05567:
05568: break;
05569: default:
05570: jj_la1[152] = jj_gen;
05571: jj_consume_token(-1);
05572: throw new ParseException();
05573: }
05574: }
05575: }
05576: }
05577:
05578: final public void ArgumentList() throws ParseException {
05579: int argc = 0;
05580: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05581: case MODULE:
05582: case SYMBOL:
05583: case BEGIN:
05584: case DOT:
05585: case STAR:
05586: case IMPORT:
05587: case STRING_LITERAL:
05588: case RANGE:
05589: case FUNCTION:
05590: case OPEN:
05591: case SUPER:
05592: case STATIC:
05593: case CLASS:
05594: case VAR:
05595: case ET:
05596: case NEGATION:
05597: case PLUS:
05598: case MINUS:
05599: case MINUSMINUS:
05600: case PLUSPLUS:
05601: case COPYOF:
05602: case CLONEOF:
05603: case TYPEOF:
05604: case SIZEOF:
05605: case CLASSOF:
05606: case BOOLEAN:
05607: case INT:
05608: case FLOAT:
05609: case STRING:
05610: case DEFINED:
05611: case UNDEFINED:
05612: case NULL:
05613: case OPEN_BRACKET:
05614: case CARET:
05615: case DELETE:
05616: case BEGIN_LIST:
05617: case NEW:
05618: case THIS:
05619: case AT:
05620: case INTEGER_LITERAL:
05621: case FLOATING_POINT_LITERAL:
05622: case INF:
05623: case FALSE:
05624: case TRUE:
05625: case PATTERN:
05626: OneArgument();
05627: argc++;
05628: label_49: while (true) {
05629: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05630: case COMMA:
05631: ;
05632: break;
05633: default:
05634: jj_la1[153] = jj_gen;
05635: break label_49;
05636: }
05637: jj_consume_token(COMMA);
05638: OneArgument();
05639: argc++;
05640: }
05641: break;
05642: default:
05643: jj_la1[154] = jj_gen;
05644: ;
05645: }
05646: Parent argv = new ExpressionList(argc);
05647: for (int i = argc - 1; i >= 0; i--) {
05648: argv.setChild(i, pop());
05649: }
05650: push(argv);
05651: }
05652:
05653: final public void Constant() throws ParseException {
05654: Token t;
05655: Token s = null;
05656: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05657: case INTEGER_LITERAL:
05658: t = jj_consume_token(INTEGER_LITERAL);
05659: push(new ConstantNode(t.image, Conversions
05660: .parseNumber(t.image)));
05661: break;
05662: case FLOATING_POINT_LITERAL:
05663: t = jj_consume_token(FLOATING_POINT_LITERAL);
05664: push(new ConstantNode(Any.create(Any.IS_DOUBLE, t.image)));
05665: break;
05666: case STRING_LITERAL:
05667: StringBuffer buffer = new StringBuffer();
05668: label_50: while (true) {
05669: t = jj_consume_token(STRING_LITERAL);
05670: if (t.image.length() > 1) {
05671: buffer.append(t.image.substring(1,
05672: t.image.length() - 1));
05673: }
05674: if (s == null) {
05675: s = t;
05676: }
05677: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05678: case STRING_LITERAL:
05679: ;
05680: break;
05681: default:
05682: jj_la1[155] = jj_gen;
05683: break label_50;
05684: }
05685: }
05686: push(Grammar.parseString(this , toLocation(s), buffer
05687: .toString()));
05688: break;
05689: case INF:
05690: t = jj_consume_token(INF);
05691: push(ConstantNode.INF);
05692: break;
05693: case FALSE:
05694: t = jj_consume_token(FALSE);
05695: push(ConstantNode.FALSE);
05696: break;
05697: case TRUE:
05698: t = jj_consume_token(TRUE);
05699: push(ConstantNode.TRUE);
05700: break;
05701: case NULL:
05702: t = jj_consume_token(NULL);
05703: push(ConstantNode.NULL);
05704: break;
05705: case UNDEFINED:
05706: t = jj_consume_token(UNDEFINED);
05707: push(ConstantNode.UNDEFINED);
05708: break;
05709: case PATTERN:
05710: t = jj_consume_token(PATTERN);
05711: int i = t.image.lastIndexOf('/');
05712: String image;
05713: String flags;
05714: if (i > 0) {
05715: image = t.image.substring(1, i);
05716: flags = t.image.substring(i + 1);
05717: } else {
05718: image = t.image;
05719: flags = "";
05720: }
05721: Pattern pattern = null;
05722: try {
05723: pattern = ObjectPool.createPattern(image, flags);
05724: push(new ConstantNode(new AnyPattern(pattern)));
05725: } catch (MalformedPatternException e) {
05726: error(toLocation(t), "Invalid regular expression: "
05727: + e.getMessage());
05728: push(ConstantNode.UNDEFINED);
05729: }
05730: break;
05731: default:
05732: jj_la1[156] = jj_gen;
05733: jj_consume_token(-1);
05734: throw new ParseException();
05735: }
05736: }
05737:
05738: final private boolean jj_2_1(int xla) {
05739: jj_la = xla;
05740: jj_lastpos = jj_scanpos = token;
05741: boolean retval = !jj_3_1();
05742: jj_save(0, xla);
05743: return retval;
05744: }
05745:
05746: final private boolean jj_2_2(int xla) {
05747: jj_la = xla;
05748: jj_lastpos = jj_scanpos = token;
05749: boolean retval = !jj_3_2();
05750: jj_save(1, xla);
05751: return retval;
05752: }
05753:
05754: final private boolean jj_2_3(int xla) {
05755: jj_la = xla;
05756: jj_lastpos = jj_scanpos = token;
05757: boolean retval = !jj_3_3();
05758: jj_save(2, xla);
05759: return retval;
05760: }
05761:
05762: final private boolean jj_2_4(int xla) {
05763: jj_la = xla;
05764: jj_lastpos = jj_scanpos = token;
05765: boolean retval = !jj_3_4();
05766: jj_save(3, xla);
05767: return retval;
05768: }
05769:
05770: final private boolean jj_2_5(int xla) {
05771: jj_la = xla;
05772: jj_lastpos = jj_scanpos = token;
05773: boolean retval = !jj_3_5();
05774: jj_save(4, xla);
05775: return retval;
05776: }
05777:
05778: final private boolean jj_2_6(int xla) {
05779: jj_la = xla;
05780: jj_lastpos = jj_scanpos = token;
05781: boolean retval = !jj_3_6();
05782: jj_save(5, xla);
05783: return retval;
05784: }
05785:
05786: final private boolean jj_2_7(int xla) {
05787: jj_la = xla;
05788: jj_lastpos = jj_scanpos = token;
05789: boolean retval = !jj_3_7();
05790: jj_save(6, xla);
05791: return retval;
05792: }
05793:
05794: final private boolean jj_2_8(int xla) {
05795: jj_la = xla;
05796: jj_lastpos = jj_scanpos = token;
05797: boolean retval = !jj_3_8();
05798: jj_save(7, xla);
05799: return retval;
05800: }
05801:
05802: final private boolean jj_2_9(int xla) {
05803: jj_la = xla;
05804: jj_lastpos = jj_scanpos = token;
05805: boolean retval = !jj_3_9();
05806: jj_save(8, xla);
05807: return retval;
05808: }
05809:
05810: final private boolean jj_2_10(int xla) {
05811: jj_la = xla;
05812: jj_lastpos = jj_scanpos = token;
05813: boolean retval = !jj_3_10();
05814: jj_save(9, xla);
05815: return retval;
05816: }
05817:
05818: final private boolean jj_2_11(int xla) {
05819: jj_la = xla;
05820: jj_lastpos = jj_scanpos = token;
05821: boolean retval = !jj_3_11();
05822: jj_save(10, xla);
05823: return retval;
05824: }
05825:
05826: final private boolean jj_2_12(int xla) {
05827: jj_la = xla;
05828: jj_lastpos = jj_scanpos = token;
05829: boolean retval = !jj_3_12();
05830: jj_save(11, xla);
05831: return retval;
05832: }
05833:
05834: final private boolean jj_2_13(int xla) {
05835: jj_la = xla;
05836: jj_lastpos = jj_scanpos = token;
05837: boolean retval = !jj_3_13();
05838: jj_save(12, xla);
05839: return retval;
05840: }
05841:
05842: final private boolean jj_2_14(int xla) {
05843: jj_la = xla;
05844: jj_lastpos = jj_scanpos = token;
05845: boolean retval = !jj_3_14();
05846: jj_save(13, xla);
05847: return retval;
05848: }
05849:
05850: final private boolean jj_2_15(int xla) {
05851: jj_la = xla;
05852: jj_lastpos = jj_scanpos = token;
05853: boolean retval = !jj_3_15();
05854: jj_save(14, xla);
05855: return retval;
05856: }
05857:
05858: final private boolean jj_2_16(int xla) {
05859: jj_la = xla;
05860: jj_lastpos = jj_scanpos = token;
05861: boolean retval = !jj_3_16();
05862: jj_save(15, xla);
05863: return retval;
05864: }
05865:
05866: final private boolean jj_2_17(int xla) {
05867: jj_la = xla;
05868: jj_lastpos = jj_scanpos = token;
05869: boolean retval = !jj_3_17();
05870: jj_save(16, xla);
05871: return retval;
05872: }
05873:
05874: final private boolean jj_2_18(int xla) {
05875: jj_la = xla;
05876: jj_lastpos = jj_scanpos = token;
05877: boolean retval = !jj_3_18();
05878: jj_save(17, xla);
05879: return retval;
05880: }
05881:
05882: final private boolean jj_2_19(int xla) {
05883: jj_la = xla;
05884: jj_lastpos = jj_scanpos = token;
05885: boolean retval = !jj_3_19();
05886: jj_save(18, xla);
05887: return retval;
05888: }
05889:
05890: final private boolean jj_2_20(int xla) {
05891: jj_la = xla;
05892: jj_lastpos = jj_scanpos = token;
05893: boolean retval = !jj_3_20();
05894: jj_save(19, xla);
05895: return retval;
05896: }
05897:
05898: final private boolean jj_2_21(int xla) {
05899: jj_la = xla;
05900: jj_lastpos = jj_scanpos = token;
05901: boolean retval = !jj_3_21();
05902: jj_save(20, xla);
05903: return retval;
05904: }
05905:
05906: final private boolean jj_2_22(int xla) {
05907: jj_la = xla;
05908: jj_lastpos = jj_scanpos = token;
05909: boolean retval = !jj_3_22();
05910: jj_save(21, xla);
05911: return retval;
05912: }
05913:
05914: final private boolean jj_2_23(int xla) {
05915: jj_la = xla;
05916: jj_lastpos = jj_scanpos = token;
05917: boolean retval = !jj_3_23();
05918: jj_save(22, xla);
05919: return retval;
05920: }
05921:
05922: final private boolean jj_2_24(int xla) {
05923: jj_la = xla;
05924: jj_lastpos = jj_scanpos = token;
05925: boolean retval = !jj_3_24();
05926: jj_save(23, xla);
05927: return retval;
05928: }
05929:
05930: final private boolean jj_2_25(int xla) {
05931: jj_la = xla;
05932: jj_lastpos = jj_scanpos = token;
05933: boolean retval = !jj_3_25();
05934: jj_save(24, xla);
05935: return retval;
05936: }
05937:
05938: final private boolean jj_2_26(int xla) {
05939: jj_la = xla;
05940: jj_lastpos = jj_scanpos = token;
05941: boolean retval = !jj_3_26();
05942: jj_save(25, xla);
05943: return retval;
05944: }
05945:
05946: final private boolean jj_2_27(int xla) {
05947: jj_la = xla;
05948: jj_lastpos = jj_scanpos = token;
05949: boolean retval = !jj_3_27();
05950: jj_save(26, xla);
05951: return retval;
05952: }
05953:
05954: final private boolean jj_3R_279() {
05955: if (jj_scan_token(LESS))
05956: return true;
05957: if (jj_la == 0 && jj_scanpos == jj_lastpos)
05958: return false;
05959: return false;
05960: }
05961:
05962: final private boolean jj_3R_261() {
05963: if (jj_3R_264())
05964: return true;
05965: if (jj_la == 0 && jj_scanpos == jj_lastpos)
05966: return false;
05967: Token xsp;
05968: while (true) {
05969: xsp = jj_scanpos;
05970: if (jj_3R_270()) {
05971: jj_scanpos = xsp;
05972: break;
05973: }
05974: if (jj_la == 0 && jj_scanpos == jj_lastpos)
05975: return false;
05976: }
05977: return false;
05978: }
05979:
05980: final private boolean jj_3R_389() {
05981: if (jj_scan_token(IF))
05982: return true;
05983: if (jj_la == 0 && jj_scanpos == jj_lastpos)
05984: return false;
05985: if (jj_scan_token(OPEN))
05986: return true;
05987: if (jj_la == 0 && jj_scanpos == jj_lastpos)
05988: return false;
05989: if (jj_3R_116())
05990: return true;
05991: if (jj_la == 0 && jj_scanpos == jj_lastpos)
05992: return false;
05993: if (jj_scan_token(CLOSE))
05994: return true;
05995: if (jj_la == 0 && jj_scanpos == jj_lastpos)
05996: return false;
05997: if (jj_3R_385())
05998: return true;
05999: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06000: return false;
06001: return false;
06002: }
06003:
06004: final private boolean jj_3R_270() {
06005: Token xsp;
06006: xsp = jj_scanpos;
06007: if (jj_3R_279()) {
06008: jj_scanpos = xsp;
06009: if (jj_3R_280()) {
06010: jj_scanpos = xsp;
06011: if (jj_3R_281()) {
06012: jj_scanpos = xsp;
06013: if (jj_3R_282())
06014: return true;
06015: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06016: return false;
06017: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06018: return false;
06019: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06020: return false;
06021: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06022: return false;
06023: if (jj_3R_264())
06024: return true;
06025: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06026: return false;
06027: return false;
06028: }
06029:
06030: final private boolean jj_3R_250() {
06031: if (jj_3R_116())
06032: return true;
06033: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06034: return false;
06035: return false;
06036: }
06037:
06038: final private boolean jj_3R_383() {
06039: if (jj_3R_162())
06040: return true;
06041: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06042: return false;
06043: if (jj_3R_385())
06044: return true;
06045: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06046: return false;
06047: return false;
06048: }
06049:
06050: final private boolean jj_3R_132() {
06051: if (jj_scan_token(WHILE))
06052: return true;
06053: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06054: return false;
06055: if (jj_scan_token(OPEN))
06056: return true;
06057: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06058: return false;
06059: if (jj_3R_116())
06060: return true;
06061: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06062: return false;
06063: if (jj_scan_token(CLOSE))
06064: return true;
06065: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06066: return false;
06067: if (jj_3R_52())
06068: return true;
06069: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06070: return false;
06071: return false;
06072: }
06073:
06074: final private boolean jj_3R_258() {
06075: if (jj_3R_52())
06076: return true;
06077: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06078: return false;
06079: return false;
06080: }
06081:
06082: final private boolean jj_3R_266() {
06083: if (jj_scan_token(BOOLEAN_AND))
06084: return true;
06085: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06086: return false;
06087: if (jj_3R_248())
06088: return true;
06089: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06090: return false;
06091: return false;
06092: }
06093:
06094: final private boolean jj_3R_388() {
06095: if (jj_3R_75())
06096: return true;
06097: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06098: return false;
06099: return false;
06100: }
06101:
06102: final private boolean jj_3R_387() {
06103: if (jj_3R_383())
06104: return true;
06105: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06106: return false;
06107: return false;
06108: }
06109:
06110: final private boolean jj_3R_386() {
06111: if (jj_3R_389())
06112: return true;
06113: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06114: return false;
06115: return false;
06116: }
06117:
06118: final private boolean jj_3R_244() {
06119: if (jj_scan_token(_DEFAULT))
06120: return true;
06121: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06122: return false;
06123: if (jj_scan_token(COLON))
06124: return true;
06125: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06126: return false;
06127: Token xsp;
06128: while (true) {
06129: xsp = jj_scanpos;
06130: if (jj_3R_258()) {
06131: jj_scanpos = xsp;
06132: break;
06133: }
06134: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06135: return false;
06136: }
06137: return false;
06138: }
06139:
06140: final private boolean jj_3R_276() {
06141: if (jj_scan_token(EXACT_COMPARE))
06142: return true;
06143: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06144: return false;
06145: return false;
06146: }
06147:
06148: final private boolean jj_3R_385() {
06149: Token xsp;
06150: xsp = jj_scanpos;
06151: if (jj_3R_386()) {
06152: jj_scanpos = xsp;
06153: if (jj_3R_387()) {
06154: jj_scanpos = xsp;
06155: if (jj_3R_388())
06156: return true;
06157: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06158: return false;
06159: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06160: return false;
06161: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06162: return false;
06163: return false;
06164: }
06165:
06166: final private boolean jj_3R_275() {
06167: if (jj_scan_token(COMPARE))
06168: return true;
06169: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06170: return false;
06171: return false;
06172: }
06173:
06174: final private boolean jj_3R_257() {
06175: if (jj_3R_52())
06176: return true;
06177: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06178: return false;
06179: return false;
06180: }
06181:
06182: final private boolean jj_3R_248() {
06183: if (jj_3R_261())
06184: return true;
06185: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06186: return false;
06187: Token xsp;
06188: while (true) {
06189: xsp = jj_scanpos;
06190: if (jj_3R_268()) {
06191: jj_scanpos = xsp;
06192: break;
06193: }
06194: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06195: return false;
06196: }
06197: return false;
06198: }
06199:
06200: final private boolean jj_3R_274() {
06201: if (jj_scan_token(EXACT_NOT_EQUAL))
06202: return true;
06203: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06204: return false;
06205: return false;
06206: }
06207:
06208: final private boolean jj_3_3() {
06209: if (jj_3R_52())
06210: return true;
06211: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06212: return false;
06213: return false;
06214: }
06215:
06216: final private boolean jj_3R_273() {
06217: if (jj_scan_token(EXACT_EQUAL))
06218: return true;
06219: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06220: return false;
06221: return false;
06222: }
06223:
06224: final private boolean jj_3R_272() {
06225: if (jj_scan_token(NOT_EQUAL))
06226: return true;
06227: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06228: return false;
06229: return false;
06230: }
06231:
06232: final private boolean jj_3R_271() {
06233: if (jj_scan_token(EQUAL))
06234: return true;
06235: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06236: return false;
06237: return false;
06238: }
06239:
06240: final private boolean jj_3R_263() {
06241: if (jj_scan_token(BOOLEAN_XOR))
06242: return true;
06243: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06244: return false;
06245: if (jj_3R_234())
06246: return true;
06247: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06248: return false;
06249: return false;
06250: }
06251:
06252: final private boolean jj_3R_268() {
06253: Token xsp;
06254: xsp = jj_scanpos;
06255: if (jj_3R_271()) {
06256: jj_scanpos = xsp;
06257: if (jj_3R_272()) {
06258: jj_scanpos = xsp;
06259: if (jj_3R_273()) {
06260: jj_scanpos = xsp;
06261: if (jj_3R_274()) {
06262: jj_scanpos = xsp;
06263: if (jj_3R_275()) {
06264: jj_scanpos = xsp;
06265: if (jj_3R_276())
06266: return true;
06267: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06268: return false;
06269: } else if (jj_la == 0
06270: && jj_scanpos == jj_lastpos)
06271: return false;
06272: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06273: return false;
06274: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06275: return false;
06276: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06277: return false;
06278: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06279: return false;
06280: if (jj_3R_261())
06281: return true;
06282: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06283: return false;
06284: return false;
06285: }
06286:
06287: final private boolean jj_3R_256() {
06288: if (jj_scan_token(COMMA))
06289: return true;
06290: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06291: return false;
06292: if (jj_3R_177())
06293: return true;
06294: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06295: return false;
06296: return false;
06297: }
06298:
06299: final private boolean jj_3R_231() {
06300: Token xsp;
06301: xsp = jj_scanpos;
06302: if (jj_3R_243()) {
06303: jj_scanpos = xsp;
06304: if (jj_3R_244())
06305: return true;
06306: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06307: return false;
06308: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06309: return false;
06310: return false;
06311: }
06312:
06313: final private boolean jj_3R_243() {
06314: if (jj_scan_token(CASE))
06315: return true;
06316: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06317: return false;
06318: if (jj_3R_177())
06319: return true;
06320: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06321: return false;
06322: Token xsp;
06323: while (true) {
06324: xsp = jj_scanpos;
06325: if (jj_3R_256()) {
06326: jj_scanpos = xsp;
06327: break;
06328: }
06329: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06330: return false;
06331: }
06332: if (jj_scan_token(COLON))
06333: return true;
06334: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06335: return false;
06336: while (true) {
06337: xsp = jj_scanpos;
06338: if (jj_3R_257()) {
06339: jj_scanpos = xsp;
06340: break;
06341: }
06342: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06343: return false;
06344: }
06345: return false;
06346: }
06347:
06348: final private boolean jj_3R_234() {
06349: if (jj_3R_248())
06350: return true;
06351: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06352: return false;
06353: Token xsp;
06354: while (true) {
06355: xsp = jj_scanpos;
06356: if (jj_3R_266()) {
06357: jj_scanpos = xsp;
06358: break;
06359: }
06360: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06361: return false;
06362: }
06363: return false;
06364: }
06365:
06366: final private boolean jj_3R_190() {
06367: if (jj_scan_token(OPEN_BRACKET))
06368: return true;
06369: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06370: return false;
06371: if (jj_scan_token(CLOSE_BRACKET))
06372: return true;
06373: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06374: return false;
06375: return false;
06376: }
06377:
06378: final private boolean jj_3R_259() {
06379: if (jj_scan_token(BOOLEAN_OR))
06380: return true;
06381: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06382: return false;
06383: if (jj_3R_223())
06384: return true;
06385: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06386: return false;
06387: return false;
06388: }
06389:
06390: final private boolean jj_3R_136() {
06391: if (jj_scan_token(SWITCH))
06392: return true;
06393: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06394: return false;
06395: if (jj_scan_token(OPEN))
06396: return true;
06397: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06398: return false;
06399: if (jj_3R_116())
06400: return true;
06401: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06402: return false;
06403: if (jj_scan_token(CLOSE))
06404: return true;
06405: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06406: return false;
06407: if (jj_scan_token(BEGIN))
06408: return true;
06409: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06410: return false;
06411: Token xsp;
06412: while (true) {
06413: xsp = jj_scanpos;
06414: if (jj_3R_231()) {
06415: jj_scanpos = xsp;
06416: break;
06417: }
06418: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06419: return false;
06420: }
06421: if (jj_scan_token(END))
06422: return true;
06423: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06424: return false;
06425: return false;
06426: }
06427:
06428: final private boolean jj_3_24() {
06429: if (jj_scan_token(OPEN_BRACKET))
06430: return true;
06431: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06432: return false;
06433: if (jj_3R_74())
06434: return true;
06435: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06436: return false;
06437: if (jj_scan_token(CLOSE_BRACKET))
06438: return true;
06439: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06440: return false;
06441: return false;
06442: }
06443:
06444: final private boolean jj_3R_223() {
06445: if (jj_3R_234())
06446: return true;
06447: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06448: return false;
06449: Token xsp;
06450: while (true) {
06451: xsp = jj_scanpos;
06452: if (jj_3R_263()) {
06453: jj_scanpos = xsp;
06454: break;
06455: }
06456: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06457: return false;
06458: }
06459: return false;
06460: }
06461:
06462: final private boolean jj_3R_201() {
06463: if (jj_scan_token(COPYOF))
06464: return true;
06465: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06466: return false;
06467: return false;
06468: }
06469:
06470: final private boolean jj_3R_200() {
06471: if (jj_scan_token(CLONEOF))
06472: return true;
06473: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06474: return false;
06475: return false;
06476: }
06477:
06478: final private boolean jj_3R_199() {
06479: if (jj_scan_token(TYPEOF))
06480: return true;
06481: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06482: return false;
06483: return false;
06484: }
06485:
06486: final private boolean jj_3R_246() {
06487: if (jj_scan_token(RANGE))
06488: return true;
06489: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06490: return false;
06491: Token xsp;
06492: xsp = jj_scanpos;
06493: if (jj_3R_260())
06494: jj_scanpos = xsp;
06495: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06496: return false;
06497: return false;
06498: }
06499:
06500: final private boolean jj_3R_198() {
06501: if (jj_scan_token(SIZEOF))
06502: return true;
06503: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06504: return false;
06505: return false;
06506: }
06507:
06508: final private boolean jj_3R_213() {
06509: if (jj_3R_223())
06510: return true;
06511: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06512: return false;
06513: Token xsp;
06514: while (true) {
06515: xsp = jj_scanpos;
06516: if (jj_3R_259()) {
06517: jj_scanpos = xsp;
06518: break;
06519: }
06520: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06521: return false;
06522: }
06523: return false;
06524: }
06525:
06526: final private boolean jj_3R_54() {
06527: if (jj_scan_token(SYMBOL))
06528: return true;
06529: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06530: return false;
06531: if (jj_scan_token(COLON))
06532: return true;
06533: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06534: return false;
06535: return false;
06536: }
06537:
06538: final private boolean jj_3R_197() {
06539: if (jj_scan_token(CLASS))
06540: return true;
06541: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06542: return false;
06543: return false;
06544: }
06545:
06546: final private boolean jj_3R_245() {
06547: if (jj_3R_213())
06548: return true;
06549: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06550: return false;
06551: return false;
06552: }
06553:
06554: final private boolean jj_3R_260() {
06555: if (jj_3R_213())
06556: return true;
06557: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06558: return false;
06559: return false;
06560: }
06561:
06562: final private boolean jj_3R_229() {
06563: if (jj_scan_token(ELSE))
06564: return true;
06565: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06566: return false;
06567: if (jj_3R_52())
06568: return true;
06569: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06570: return false;
06571: return false;
06572: }
06573:
06574: final private boolean jj_3R_73() {
06575: if (jj_3R_115())
06576: return true;
06577: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06578: return false;
06579: return false;
06580: }
06581:
06582: final private boolean jj_3R_72() {
06583: if (jj_scan_token(OPEN))
06584: return true;
06585: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06586: return false;
06587: if (jj_3R_114())
06588: return true;
06589: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06590: return false;
06591: if (jj_scan_token(CLOSE))
06592: return true;
06593: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06594: return false;
06595: return false;
06596: }
06597:
06598: final private boolean jj_3R_210() {
06599: if (jj_3R_213())
06600: return true;
06601: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06602: return false;
06603: Token xsp;
06604: xsp = jj_scanpos;
06605: if (jj_3R_246())
06606: jj_scanpos = xsp;
06607: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06608: return false;
06609: return false;
06610: }
06611:
06612: final private boolean jj_3_23() {
06613: Token xsp;
06614: xsp = jj_scanpos;
06615: if (jj_3R_72()) {
06616: jj_scanpos = xsp;
06617: if (jj_3R_73())
06618: return true;
06619: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06620: return false;
06621: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06622: return false;
06623: return false;
06624: }
06625:
06626: final private boolean jj_3R_196() {
06627: if (jj_scan_token(SYMBOL))
06628: return true;
06629: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06630: return false;
06631: Token xsp;
06632: xsp = jj_scanpos;
06633: if (jj_3_23())
06634: jj_scanpos = xsp;
06635: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06636: return false;
06637: return false;
06638: }
06639:
06640: final private boolean jj_3R_131() {
06641: if (jj_scan_token(IF))
06642: return true;
06643: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06644: return false;
06645: if (jj_scan_token(OPEN))
06646: return true;
06647: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06648: return false;
06649: if (jj_3R_116())
06650: return true;
06651: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06652: return false;
06653: if (jj_scan_token(CLOSE))
06654: return true;
06655: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06656: return false;
06657: if (jj_3R_52())
06658: return true;
06659: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06660: return false;
06661: Token xsp;
06662: xsp = jj_scanpos;
06663: if (jj_3R_229())
06664: jj_scanpos = xsp;
06665: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06666: return false;
06667: return false;
06668: }
06669:
06670: final private boolean jj_3R_209() {
06671: if (jj_scan_token(RANGE))
06672: return true;
06673: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06674: return false;
06675: Token xsp;
06676: xsp = jj_scanpos;
06677: if (jj_3R_245())
06678: jj_scanpos = xsp;
06679: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06680: return false;
06681: return false;
06682: }
06683:
06684: final private boolean jj_3R_180() {
06685: if (jj_3R_178())
06686: return true;
06687: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06688: return false;
06689: return false;
06690: }
06691:
06692: final private boolean jj_3R_203() {
06693: Token xsp;
06694: xsp = jj_scanpos;
06695: if (jj_3R_209()) {
06696: jj_scanpos = xsp;
06697: if (jj_3R_210())
06698: return true;
06699: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06700: return false;
06701: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06702: return false;
06703: return false;
06704: }
06705:
06706: final private boolean jj_3R_179() {
06707: if (jj_3R_178())
06708: return true;
06709: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06710: return false;
06711: return false;
06712: }
06713:
06714: final private boolean jj_3R_207() {
06715: if (jj_3R_115())
06716: return true;
06717: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06718: return false;
06719: return false;
06720: }
06721:
06722: final private boolean jj_3R_206() {
06723: if (jj_scan_token(OPEN))
06724: return true;
06725: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06726: return false;
06727: if (jj_3R_114())
06728: return true;
06729: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06730: return false;
06731: if (jj_scan_token(CLOSE))
06732: return true;
06733: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06734: return false;
06735: return false;
06736: }
06737:
06738: final private boolean jj_3R_212() {
06739: if (jj_scan_token(MAP))
06740: return true;
06741: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06742: return false;
06743: if (jj_3R_191())
06744: return true;
06745: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06746: return false;
06747: return false;
06748: }
06749:
06750: final private boolean jj_3R_224() {
06751: if (jj_scan_token(COMMA))
06752: return true;
06753: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06754: return false;
06755: if (jj_scan_token(RANGE))
06756: return true;
06757: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06758: return false;
06759: if (jj_3R_225())
06760: return true;
06761: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06762: return false;
06763: return false;
06764: }
06765:
06766: final private boolean jj_3R_247() {
06767: if (jj_3R_191())
06768: return true;
06769: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06770: return false;
06771: return false;
06772: }
06773:
06774: final private boolean jj_3_2() {
06775: if (jj_scan_token(COMMA))
06776: return true;
06777: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06778: return false;
06779: if (jj_3R_51())
06780: return true;
06781: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06782: return false;
06783: return false;
06784: }
06785:
06786: final private boolean jj_3R_215() {
06787: if (jj_scan_token(RANGE))
06788: return true;
06789: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06790: return false;
06791: if (jj_3R_225())
06792: return true;
06793: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06794: return false;
06795: return false;
06796: }
06797:
06798: final private boolean jj_3R_195() {
06799: if (jj_scan_token(OPEN))
06800: return true;
06801: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06802: return false;
06803: if (jj_3R_60())
06804: return true;
06805: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06806: return false;
06807: if (jj_scan_token(CLOSE))
06808: return true;
06809: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06810: return false;
06811: Token xsp;
06812: xsp = jj_scanpos;
06813: if (jj_3R_206()) {
06814: jj_scanpos = xsp;
06815: if (jj_3R_207())
06816: return true;
06817: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06818: return false;
06819: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06820: return false;
06821: return false;
06822: }
06823:
06824: final private boolean jj_3R_154() {
06825: if (jj_scan_token(PRINTBR))
06826: return true;
06827: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06828: return false;
06829: Token xsp;
06830: xsp = jj_scanpos;
06831: if (jj_3R_180())
06832: jj_scanpos = xsp;
06833: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06834: return false;
06835: return false;
06836: }
06837:
06838: final private boolean jj_3R_233() {
06839: if (jj_scan_token(HOOK))
06840: return true;
06841: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06842: return false;
06843: if (jj_3R_191())
06844: return true;
06845: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06846: return false;
06847: if (jj_scan_token(COLON))
06848: return true;
06849: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06850: return false;
06851: Token xsp;
06852: xsp = jj_scanpos;
06853: if (jj_3R_247())
06854: jj_scanpos = xsp;
06855: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06856: return false;
06857: return false;
06858: }
06859:
06860: final private boolean jj_3R_214() {
06861: if (jj_3R_51())
06862: return true;
06863: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06864: return false;
06865: Token xsp;
06866: while (true) {
06867: xsp = jj_scanpos;
06868: if (jj_3_2()) {
06869: jj_scanpos = xsp;
06870: break;
06871: }
06872: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06873: return false;
06874: }
06875: xsp = jj_scanpos;
06876: if (jj_3R_224())
06877: jj_scanpos = xsp;
06878: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06879: return false;
06880: return false;
06881: }
06882:
06883: final private boolean jj_3R_189() {
06884: if (jj_scan_token(DOT))
06885: return true;
06886: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06887: return false;
06888: Token xsp;
06889: xsp = jj_scanpos;
06890: if (jj_3R_195()) {
06891: jj_scanpos = xsp;
06892: if (jj_3R_196()) {
06893: jj_scanpos = xsp;
06894: if (jj_3R_197()) {
06895: jj_scanpos = xsp;
06896: if (jj_3R_198()) {
06897: jj_scanpos = xsp;
06898: if (jj_3R_199()) {
06899: jj_scanpos = xsp;
06900: if (jj_3R_200()) {
06901: jj_scanpos = xsp;
06902: if (jj_3R_201())
06903: return true;
06904: if (jj_la == 0
06905: && jj_scanpos == jj_lastpos)
06906: return false;
06907: } else if (jj_la == 0
06908: && jj_scanpos == jj_lastpos)
06909: return false;
06910: } else if (jj_la == 0
06911: && jj_scanpos == jj_lastpos)
06912: return false;
06913: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06914: return false;
06915: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06916: return false;
06917: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06918: return false;
06919: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06920: return false;
06921: return false;
06922: }
06923:
06924: final private boolean jj_3R_211() {
06925: Token xsp;
06926: xsp = jj_scanpos;
06927: if (jj_3R_214()) {
06928: jj_scanpos = xsp;
06929: if (jj_3R_215())
06930: return true;
06931: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06932: return false;
06933: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06934: return false;
06935: return false;
06936: }
06937:
06938: final private boolean jj_3R_191() {
06939: if (jj_3R_203())
06940: return true;
06941: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06942: return false;
06943: Token xsp;
06944: xsp = jj_scanpos;
06945: if (jj_3R_222())
06946: jj_scanpos = xsp;
06947: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06948: return false;
06949: return false;
06950: }
06951:
06952: final private boolean jj_3R_232() {
06953: if (jj_scan_token(HOOKHOOK))
06954: return true;
06955: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06956: return false;
06957: if (jj_3R_191())
06958: return true;
06959: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06960: return false;
06961: return false;
06962: }
06963:
06964: final private boolean jj_3R_153() {
06965: if (jj_scan_token(PRINTLN))
06966: return true;
06967: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06968: return false;
06969: Token xsp;
06970: xsp = jj_scanpos;
06971: if (jj_3R_179())
06972: jj_scanpos = xsp;
06973: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06974: return false;
06975: return false;
06976: }
06977:
06978: final private boolean jj_3R_188() {
06979: if (jj_3R_115())
06980: return true;
06981: if (jj_la == 0 && jj_scanpos == jj_lastpos)
06982: return false;
06983: return false;
06984: }
06985:
06986: final private boolean jj_3R_205() {
06987: Token xsp;
06988: xsp = jj_scanpos;
06989: if (jj_3R_211())
06990: jj_scanpos = xsp;
06991: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
06992: return false;
06993: return false;
06994: }
06995:
06996: final private boolean jj_3R_222() {
06997: Token xsp;
06998: xsp = jj_scanpos;
06999: if (jj_3R_232()) {
07000: jj_scanpos = xsp;
07001: if (jj_3R_233())
07002: return true;
07003: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07004: return false;
07005: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07006: return false;
07007: return false;
07008: }
07009:
07010: final private boolean jj_3R_152() {
07011: if (jj_scan_token(HOOK))
07012: return true;
07013: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07014: return false;
07015: if (jj_3R_178())
07016: return true;
07017: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07018: return false;
07019: return false;
07020: }
07021:
07022: final private boolean jj_3R_208() {
07023: if (jj_scan_token(ARROW))
07024: return true;
07025: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07026: return false;
07027: if (jj_3R_175())
07028: return true;
07029: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07030: return false;
07031: return false;
07032: }
07033:
07034: final private boolean jj_3R_174() {
07035: Token xsp;
07036: xsp = jj_scanpos;
07037: if (jj_3R_187()) {
07038: jj_scanpos = xsp;
07039: if (jj_3R_188()) {
07040: jj_scanpos = xsp;
07041: if (jj_3R_189()) {
07042: jj_scanpos = xsp;
07043: if (jj_3_24()) {
07044: jj_scanpos = xsp;
07045: if (jj_3R_190())
07046: return true;
07047: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07048: return false;
07049: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07050: return false;
07051: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07052: return false;
07053: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07054: return false;
07055: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07056: return false;
07057: return false;
07058: }
07059:
07060: final private boolean jj_3R_187() {
07061: if (jj_scan_token(OPEN))
07062: return true;
07063: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07064: return false;
07065: if (jj_3R_114())
07066: return true;
07067: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07068: return false;
07069: if (jj_scan_token(CLOSE))
07070: return true;
07071: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07072: return false;
07073: return false;
07074: }
07075:
07076: final private boolean jj_3R_151() {
07077: if (jj_scan_token(PRINT))
07078: return true;
07079: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07080: return false;
07081: if (jj_3R_178())
07082: return true;
07083: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07084: return false;
07085: return false;
07086: }
07087:
07088: final private boolean jj_3R_119() {
07089: Token xsp;
07090: xsp = jj_scanpos;
07091: if (jj_3R_151()) {
07092: jj_scanpos = xsp;
07093: if (jj_3R_152()) {
07094: jj_scanpos = xsp;
07095: if (jj_3R_153()) {
07096: jj_scanpos = xsp;
07097: if (jj_3R_154())
07098: return true;
07099: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07100: return false;
07101: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07102: return false;
07103: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07104: return false;
07105: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07106: return false;
07107: if (jj_3R_155())
07108: return true;
07109: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07110: return false;
07111: return false;
07112: }
07113:
07114: final private boolean jj_3R_143() {
07115: Token xsp;
07116: while (true) {
07117: xsp = jj_scanpos;
07118: if (jj_3R_174()) {
07119: jj_scanpos = xsp;
07120: break;
07121: }
07122: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07123: return false;
07124: }
07125: return false;
07126: }
07127:
07128: final private boolean jj_3R_175() {
07129: if (jj_3R_191())
07130: return true;
07131: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07132: return false;
07133: Token xsp;
07134: while (true) {
07135: xsp = jj_scanpos;
07136: if (jj_3R_212()) {
07137: jj_scanpos = xsp;
07138: break;
07139: }
07140: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07141: return false;
07142: }
07143: return false;
07144: }
07145:
07146: final private boolean jj_3R_71() {
07147: if (jj_scan_token(BEGIN))
07148: return true;
07149: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07150: return false;
07151: return false;
07152: }
07153:
07154: final private boolean jj_3R_202() {
07155: if (jj_scan_token(FOREACH))
07156: return true;
07157: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07158: return false;
07159: if (jj_3R_115())
07160: return true;
07161: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07162: return false;
07163: return false;
07164: }
07165:
07166: final private boolean jj_3_22() {
07167: Token xsp;
07168: xsp = jj_scanpos;
07169: if (jj_3R_70()) {
07170: jj_scanpos = xsp;
07171: if (jj_3R_71())
07172: return true;
07173: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07174: return false;
07175: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07176: return false;
07177: return false;
07178: }
07179:
07180: final private boolean jj_3R_70() {
07181: if (jj_scan_token(OPEN))
07182: return true;
07183: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07184: return false;
07185: return false;
07186: }
07187:
07188: final private boolean jj_3R_225() {
07189: if (jj_scan_token(SYMBOL))
07190: return true;
07191: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07192: return false;
07193: return false;
07194: }
07195:
07196: final private boolean jj_3R_145() {
07197: if (jj_3R_175())
07198: return true;
07199: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07200: return false;
07201: Token xsp;
07202: while (true) {
07203: xsp = jj_scanpos;
07204: if (jj_3R_208()) {
07205: jj_scanpos = xsp;
07206: break;
07207: }
07208: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07209: return false;
07210: }
07211: return false;
07212: }
07213:
07214: final private boolean jj_3R_173() {
07215: if (jj_3R_115())
07216: return true;
07217: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07218: return false;
07219: return false;
07220: }
07221:
07222: final private boolean jj_3_21() {
07223: if (jj_3R_69())
07224: return true;
07225: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07226: return false;
07227: return false;
07228: }
07229:
07230: final private boolean jj_3R_172() {
07231: if (jj_scan_token(OPEN))
07232: return true;
07233: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07234: return false;
07235: if (jj_3R_114())
07236: return true;
07237: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07238: return false;
07239: if (jj_scan_token(CLOSE))
07240: return true;
07241: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07242: return false;
07243: return false;
07244: }
07245:
07246: final private boolean jj_3R_235() {
07247: if (jj_scan_token(ASSIGN))
07248: return true;
07249: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07250: return false;
07251: if (jj_3R_60())
07252: return true;
07253: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07254: return false;
07255: return false;
07256: }
07257:
07258: final private boolean jj_3R_142() {
07259: Token xsp;
07260: xsp = jj_scanpos;
07261: if (jj_3R_172()) {
07262: jj_scanpos = xsp;
07263: if (jj_3R_173())
07264: return true;
07265: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07266: return false;
07267: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07268: return false;
07269: return false;
07270: }
07271:
07272: final private boolean jj_3R_265() {
07273: if (jj_scan_token(COMMA))
07274: return true;
07275: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07276: return false;
07277: return false;
07278: }
07279:
07280: final private boolean jj_3R_111() {
07281: if (jj_3R_145())
07282: return true;
07283: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07284: return false;
07285: Token xsp;
07286: while (true) {
07287: xsp = jj_scanpos;
07288: if (jj_3R_202()) {
07289: jj_scanpos = xsp;
07290: break;
07291: }
07292: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07293: return false;
07294: }
07295: return false;
07296: }
07297:
07298: final private boolean jj_3R_171() {
07299: if (jj_3R_69())
07300: return true;
07301: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07302: return false;
07303: return false;
07304: }
07305:
07306: final private boolean jj_3R_262() {
07307: if (jj_scan_token(COMMA))
07308: return true;
07309: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07310: return false;
07311: Token xsp;
07312: while (true) {
07313: xsp = jj_scanpos;
07314: if (jj_3R_265()) {
07315: jj_scanpos = xsp;
07316: break;
07317: }
07318: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07319: return false;
07320: }
07321: return false;
07322: }
07323:
07324: final private boolean jj_3R_249() {
07325: if (jj_scan_token(COMMA))
07326: return true;
07327: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07328: return false;
07329: Token xsp;
07330: xsp = jj_scanpos;
07331: if (jj_3R_262())
07332: jj_scanpos = xsp;
07333: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07334: return false;
07335: if (jj_3R_177())
07336: return true;
07337: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07338: return false;
07339: return false;
07340: }
07341:
07342: final private boolean jj_3_20() {
07343: if (jj_3R_69())
07344: return true;
07345: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07346: return false;
07347: return false;
07348: }
07349:
07350: final private boolean jj_3R_51() {
07351: if (jj_scan_token(SYMBOL))
07352: return true;
07353: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07354: return false;
07355: Token xsp;
07356: xsp = jj_scanpos;
07357: if (jj_3R_235())
07358: jj_scanpos = xsp;
07359: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07360: return false;
07361: return false;
07362: }
07363:
07364: final private boolean jj_3R_178() {
07365: if (jj_3R_177())
07366: return true;
07367: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07368: return false;
07369: Token xsp;
07370: while (true) {
07371: xsp = jj_scanpos;
07372: if (jj_3R_249()) {
07373: jj_scanpos = xsp;
07374: break;
07375: }
07376: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07377: return false;
07378: }
07379: return false;
07380: }
07381:
07382: final private boolean jj_3R_141() {
07383: if (jj_scan_token(DOT))
07384: return true;
07385: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07386: return false;
07387: if (jj_scan_token(SYMBOL))
07388: return true;
07389: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07390: return false;
07391: Token xsp;
07392: while (true) {
07393: xsp = jj_scanpos;
07394: if (jj_3R_171()) {
07395: jj_scanpos = xsp;
07396: break;
07397: }
07398: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07399: return false;
07400: }
07401: return false;
07402: }
07403:
07404: final private boolean jj_3R_60() {
07405: if (jj_3R_111())
07406: return true;
07407: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07408: return false;
07409: return false;
07410: }
07411:
07412: final private boolean jj_3R_170() {
07413: if (jj_3R_69())
07414: return true;
07415: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07416: return false;
07417: return false;
07418: }
07419:
07420: final private boolean jj_3R_118() {
07421: if (jj_scan_token(SEMICOLON))
07422: return true;
07423: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07424: return false;
07425: return false;
07426: }
07427:
07428: final private boolean jj_3R_137() {
07429: if (jj_3R_116())
07430: return true;
07431: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07432: return false;
07433: if (jj_3R_155())
07434: return true;
07435: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07436: return false;
07437: return false;
07438: }
07439:
07440: final private boolean jj_3_15() {
07441: if (jj_scan_token(COMMA))
07442: return true;
07443: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07444: return false;
07445: return false;
07446: }
07447:
07448: final private boolean jj_3_14() {
07449: if (jj_scan_token(COMMA))
07450: return true;
07451: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07452: return false;
07453: if (jj_3R_60())
07454: return true;
07455: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07456: return false;
07457: return false;
07458: }
07459:
07460: final private boolean jj_3R_74() {
07461: if (jj_3R_116())
07462: return true;
07463: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07464: return false;
07465: Token xsp;
07466: while (true) {
07467: xsp = jj_scanpos;
07468: if (jj_3_14()) {
07469: jj_scanpos = xsp;
07470: break;
07471: }
07472: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07473: return false;
07474: }
07475: xsp = jj_scanpos;
07476: if (jj_3_15())
07477: jj_scanpos = xsp;
07478: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07479: return false;
07480: return false;
07481: }
07482:
07483: final private boolean jj_3R_169() {
07484: if (jj_scan_token(FUNCTION))
07485: return true;
07486: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07487: return false;
07488: return false;
07489: }
07490:
07491: final private boolean jj_3R_168() {
07492: if (jj_scan_token(SUPER))
07493: return true;
07494: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07495: return false;
07496: return false;
07497: }
07498:
07499: final private boolean jj_3R_167() {
07500: if (jj_scan_token(THIS))
07501: return true;
07502: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07503: return false;
07504: return false;
07505: }
07506:
07507: final private boolean jj_3R_166() {
07508: if (jj_scan_token(STATIC))
07509: return true;
07510: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07511: return false;
07512: return false;
07513: }
07514:
07515: final private boolean jj_3R_165() {
07516: if (jj_scan_token(CLASS))
07517: return true;
07518: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07519: return false;
07520: return false;
07521: }
07522:
07523: final private boolean jj_3R_164() {
07524: if (jj_scan_token(MODULE))
07525: return true;
07526: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07527: return false;
07528: return false;
07529: }
07530:
07531: final private boolean jj_3R_186() {
07532: if (jj_scan_token(VAR))
07533: return true;
07534: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07535: return false;
07536: return false;
07537: }
07538:
07539: final private boolean jj_3R_163() {
07540: Token xsp;
07541: xsp = jj_scanpos;
07542: if (jj_3R_186())
07543: jj_scanpos = xsp;
07544: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07545: return false;
07546: if (jj_scan_token(SYMBOL))
07547: return true;
07548: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07549: return false;
07550: return false;
07551: }
07552:
07553: final private boolean jj_3R_140() {
07554: Token xsp;
07555: xsp = jj_scanpos;
07556: if (jj_3R_163()) {
07557: jj_scanpos = xsp;
07558: if (jj_3R_164()) {
07559: jj_scanpos = xsp;
07560: if (jj_3R_165()) {
07561: jj_scanpos = xsp;
07562: if (jj_3R_166()) {
07563: jj_scanpos = xsp;
07564: if (jj_3R_167()) {
07565: jj_scanpos = xsp;
07566: if (jj_3R_168()) {
07567: jj_scanpos = xsp;
07568: if (jj_3R_169())
07569: return true;
07570: if (jj_la == 0
07571: && jj_scanpos == jj_lastpos)
07572: return false;
07573: } else if (jj_la == 0
07574: && jj_scanpos == jj_lastpos)
07575: return false;
07576: } else if (jj_la == 0
07577: && jj_scanpos == jj_lastpos)
07578: return false;
07579: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07580: return false;
07581: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07582: return false;
07583: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07584: return false;
07585: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07586: return false;
07587: while (true) {
07588: xsp = jj_scanpos;
07589: if (jj_3R_170()) {
07590: jj_scanpos = xsp;
07591: break;
07592: }
07593: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07594: return false;
07595: }
07596: return false;
07597: }
07598:
07599: final private boolean jj_3R_113() {
07600: if (jj_scan_token(SYMBOL))
07601: return true;
07602: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07603: return false;
07604: return false;
07605: }
07606:
07607: final private boolean jj_3R_130() {
07608: if (jj_scan_token(SYNCHRONIZED))
07609: return true;
07610: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07611: return false;
07612: if (jj_scan_token(OPEN))
07613: return true;
07614: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07615: return false;
07616: if (jj_3R_116())
07617: return true;
07618: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07619: return false;
07620: if (jj_scan_token(CLOSE))
07621: return true;
07622: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07623: return false;
07624: if (jj_3R_52())
07625: return true;
07626: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07627: return false;
07628: return false;
07629: }
07630:
07631: final private boolean jj_3R_101() {
07632: Token xsp;
07633: xsp = jj_scanpos;
07634: if (jj_3R_140()) {
07635: jj_scanpos = xsp;
07636: if (jj_3R_141())
07637: return true;
07638: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07639: return false;
07640: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07641: return false;
07642: xsp = jj_scanpos;
07643: if (jj_3R_142())
07644: jj_scanpos = xsp;
07645: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07646: return false;
07647: if (jj_3R_143())
07648: return true;
07649: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07650: return false;
07651: return false;
07652: }
07653:
07654: final private boolean jj_3R_138() {
07655: if (jj_3R_101())
07656: return true;
07657: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07658: return false;
07659: return false;
07660: }
07661:
07662: final private boolean jj_3R_112() {
07663: if (jj_scan_token(THIS))
07664: return true;
07665: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07666: return false;
07667: return false;
07668: }
07669:
07670: final private boolean jj_3R_69() {
07671: if (jj_scan_token(DOT))
07672: return true;
07673: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07674: return false;
07675: Token xsp;
07676: xsp = jj_scanpos;
07677: if (jj_3R_112()) {
07678: jj_scanpos = xsp;
07679: if (jj_3R_113())
07680: return true;
07681: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07682: return false;
07683: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07684: return false;
07685: return false;
07686: }
07687:
07688: final private boolean jj_3R_129() {
07689: if (jj_scan_token(FINALLY))
07690: return true;
07691: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07692: return false;
07693: if (jj_3R_52())
07694: return true;
07695: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07696: return false;
07697: return false;
07698: }
07699:
07700: final private boolean jj_3R_376() {
07701: if (jj_3R_115())
07702: return true;
07703: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07704: return false;
07705: return false;
07706: }
07707:
07708: final private boolean jj_3R_375() {
07709: if (jj_scan_token(OPEN))
07710: return true;
07711: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07712: return false;
07713: if (jj_3R_114())
07714: return true;
07715: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07716: return false;
07717: if (jj_scan_token(CLOSE))
07718: return true;
07719: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07720: return false;
07721: return false;
07722: }
07723:
07724: final private boolean jj_3R_334() {
07725: if (jj_scan_token(NEW))
07726: return true;
07727: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07728: return false;
07729: if (jj_3R_373())
07730: return true;
07731: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07732: return false;
07733: Token xsp;
07734: xsp = jj_scanpos;
07735: if (jj_3R_375()) {
07736: jj_scanpos = xsp;
07737: if (jj_3R_376())
07738: return true;
07739: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07740: return false;
07741: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07742: return false;
07743: return false;
07744: }
07745:
07746: final private boolean jj_3R_110() {
07747: if (jj_scan_token(ASSIGN_INIT))
07748: return true;
07749: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07750: return false;
07751: return false;
07752: }
07753:
07754: final private boolean jj_3R_109() {
07755: if (jj_scan_token(ASSIGN_CONCAT))
07756: return true;
07757: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07758: return false;
07759: return false;
07760: }
07761:
07762: final private boolean jj_3R_108() {
07763: if (jj_scan_token(ASSIGN_REMAINDER))
07764: return true;
07765: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07766: return false;
07767: return false;
07768: }
07769:
07770: final private boolean jj_3R_107() {
07771: if (jj_scan_token(ASSIGN_DIVIDE))
07772: return true;
07773: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07774: return false;
07775: return false;
07776: }
07777:
07778: final private boolean jj_3R_328() {
07779: if (jj_3R_101())
07780: return true;
07781: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07782: return false;
07783: return false;
07784: }
07785:
07786: final private boolean jj_3R_106() {
07787: if (jj_scan_token(ASSIGN_MULTIPLY))
07788: return true;
07789: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07790: return false;
07791: return false;
07792: }
07793:
07794: final private boolean jj_3R_105() {
07795: if (jj_scan_token(ASSIGN_SUBSTRACT))
07796: return true;
07797: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07798: return false;
07799: return false;
07800: }
07801:
07802: final private boolean jj_3R_104() {
07803: if (jj_scan_token(ASSIGN_ADD))
07804: return true;
07805: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07806: return false;
07807: return false;
07808: }
07809:
07810: final private boolean jj_3R_103() {
07811: if (jj_scan_token(ASSIGN))
07812: return true;
07813: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07814: return false;
07815: return false;
07816: }
07817:
07818: final private boolean jj_3R_236() {
07819: if (jj_scan_token(COMMA))
07820: return true;
07821: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07822: return false;
07823: if (jj_3R_116())
07824: return true;
07825: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07826: return false;
07827: return false;
07828: }
07829:
07830: final private boolean jj_3R_327() {
07831: if (jj_scan_token(ET))
07832: return true;
07833: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07834: return false;
07835: if (jj_3R_101())
07836: return true;
07837: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07838: return false;
07839: return false;
07840: }
07841:
07842: final private boolean jj_3R_228() {
07843: if (jj_scan_token(COLON))
07844: return true;
07845: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07846: return false;
07847: if (jj_3R_116())
07848: return true;
07849: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07850: return false;
07851: Token xsp;
07852: while (true) {
07853: xsp = jj_scanpos;
07854: if (jj_3R_236()) {
07855: jj_scanpos = xsp;
07856: break;
07857: }
07858: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07859: return false;
07860: }
07861: return false;
07862: }
07863:
07864: final private boolean jj_3R_68() {
07865: if (jj_scan_token(BOOLEAN_OR))
07866: return true;
07867: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07868: return false;
07869: return false;
07870: }
07871:
07872: final private boolean jj_3R_144() {
07873: if (jj_scan_token(ET))
07874: return true;
07875: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07876: return false;
07877: return false;
07878: }
07879:
07880: final private boolean jj_3R_326() {
07881: if (jj_scan_token(STRING))
07882: return true;
07883: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07884: return false;
07885: if (jj_3R_143())
07886: return true;
07887: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07888: return false;
07889: return false;
07890: }
07891:
07892: final private boolean jj_3R_128() {
07893: if (jj_scan_token(CATCH))
07894: return true;
07895: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07896: return false;
07897: if (jj_scan_token(OPEN))
07898: return true;
07899: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07900: return false;
07901: if (jj_3R_138())
07902: return true;
07903: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07904: return false;
07905: Token xsp;
07906: xsp = jj_scanpos;
07907: if (jj_3R_228())
07908: jj_scanpos = xsp;
07909: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07910: return false;
07911: if (jj_scan_token(CLOSE))
07912: return true;
07913: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07914: return false;
07915: if (jj_3R_52())
07916: return true;
07917: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07918: return false;
07919: return false;
07920: }
07921:
07922: final private boolean jj_3R_102() {
07923: if (jj_scan_token(COMMA))
07924: return true;
07925: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07926: return false;
07927: Token xsp;
07928: xsp = jj_scanpos;
07929: if (jj_3R_144())
07930: jj_scanpos = xsp;
07931: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07932: return false;
07933: if (jj_3R_101())
07934: return true;
07935: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07936: return false;
07937: return false;
07938: }
07939:
07940: final private boolean jj_3R_66() {
07941: if (jj_scan_token(BEGIN))
07942: return true;
07943: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07944: return false;
07945: return false;
07946: }
07947:
07948: final private boolean jj_3R_372() {
07949: if (jj_3R_101())
07950: return true;
07951: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07952: return false;
07953: return false;
07954: }
07955:
07956: final private boolean jj_3R_67() {
07957: if (jj_scan_token(PIPE))
07958: return true;
07959: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07960: return false;
07961: return false;
07962: }
07963:
07964: final private boolean jj_3R_325() {
07965: if (jj_scan_token(FLOAT))
07966: return true;
07967: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07968: return false;
07969: if (jj_3R_143())
07970: return true;
07971: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07972: return false;
07973: return false;
07974: }
07975:
07976: final private boolean jj_3R_100() {
07977: if (jj_scan_token(ET))
07978: return true;
07979: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07980: return false;
07981: return false;
07982: }
07983:
07984: final private boolean jj_3R_59() {
07985: Token xsp;
07986: xsp = jj_scanpos;
07987: if (jj_3R_100())
07988: jj_scanpos = xsp;
07989: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
07990: return false;
07991: if (jj_3R_101())
07992: return true;
07993: if (jj_la == 0 && jj_scanpos == jj_lastpos)
07994: return false;
07995: while (true) {
07996: xsp = jj_scanpos;
07997: if (jj_3R_102()) {
07998: jj_scanpos = xsp;
07999: break;
08000: }
08001: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08002: return false;
08003: }
08004: xsp = jj_scanpos;
08005: if (jj_3R_103()) {
08006: jj_scanpos = xsp;
08007: if (jj_3R_104()) {
08008: jj_scanpos = xsp;
08009: if (jj_3R_105()) {
08010: jj_scanpos = xsp;
08011: if (jj_3R_106()) {
08012: jj_scanpos = xsp;
08013: if (jj_3R_107()) {
08014: jj_scanpos = xsp;
08015: if (jj_3R_108()) {
08016: jj_scanpos = xsp;
08017: if (jj_3R_109()) {
08018: jj_scanpos = xsp;
08019: if (jj_3R_110())
08020: return true;
08021: if (jj_la == 0
08022: && jj_scanpos == jj_lastpos)
08023: return false;
08024: } else if (jj_la == 0
08025: && jj_scanpos == jj_lastpos)
08026: return false;
08027: } else if (jj_la == 0
08028: && jj_scanpos == jj_lastpos)
08029: return false;
08030: } else if (jj_la == 0
08031: && jj_scanpos == jj_lastpos)
08032: return false;
08033: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08034: return false;
08035: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08036: return false;
08037: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08038: return false;
08039: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08040: return false;
08041: if (jj_3R_74())
08042: return true;
08043: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08044: return false;
08045: return false;
08046: }
08047:
08048: final private boolean jj_3R_324() {
08049: if (jj_scan_token(INT))
08050: return true;
08051: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08052: return false;
08053: if (jj_3R_143())
08054: return true;
08055: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08056: return false;
08057: return false;
08058: }
08059:
08060: final private boolean jj_3_19() {
08061: if (jj_scan_token(BEGIN))
08062: return true;
08063: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08064: return false;
08065: Token xsp;
08066: xsp = jj_scanpos;
08067: if (jj_3R_67()) {
08068: jj_scanpos = xsp;
08069: if (jj_3R_68())
08070: return true;
08071: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08072: return false;
08073: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08074: return false;
08075: return false;
08076: }
08077:
08078: final private boolean jj_3R_322() {
08079: if (jj_3R_335())
08080: return true;
08081: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08082: return false;
08083: if (jj_3R_143())
08084: return true;
08085: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08086: return false;
08087: return false;
08088: }
08089:
08090: final private boolean jj_3R_65() {
08091: if (jj_scan_token(BEGIN_LIST))
08092: return true;
08093: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08094: return false;
08095: return false;
08096: }
08097:
08098: final private boolean jj_3R_370() {
08099: if (jj_3R_101())
08100: return true;
08101: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08102: return false;
08103: return false;
08104: }
08105:
08106: final private boolean jj_3R_323() {
08107: if (jj_scan_token(BOOLEAN))
08108: return true;
08109: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08110: return false;
08111: if (jj_3R_143())
08112: return true;
08113: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08114: return false;
08115: return false;
08116: }
08117:
08118: final private boolean jj_3R_127() {
08119: if (jj_scan_token(THROW))
08120: return true;
08121: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08122: return false;
08123: if (jj_3R_160())
08124: return true;
08125: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08126: return false;
08127: if (jj_3R_155())
08128: return true;
08129: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08130: return false;
08131: return false;
08132: }
08133:
08134: final private boolean jj_3_9() {
08135: if (jj_scan_token(FINALLY))
08136: return true;
08137: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08138: return false;
08139: return false;
08140: }
08141:
08142: final private boolean jj_3_8() {
08143: if (jj_scan_token(CATCH))
08144: return true;
08145: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08146: return false;
08147: return false;
08148: }
08149:
08150: final private boolean jj_3R_321() {
08151: if (jj_3R_115())
08152: return true;
08153: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08154: return false;
08155: if (jj_3R_143())
08156: return true;
08157: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08158: return false;
08159: return false;
08160: }
08161:
08162: final private boolean jj_3R_319() {
08163: if (jj_3R_333())
08164: return true;
08165: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08166: return false;
08167: if (jj_3R_143())
08168: return true;
08169: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08170: return false;
08171: return false;
08172: }
08173:
08174: final private boolean jj_3R_177() {
08175: if (jj_3R_60())
08176: return true;
08177: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08178: return false;
08179: return false;
08180: }
08181:
08182: final private boolean jj_3R_320() {
08183: if (jj_3R_334())
08184: return true;
08185: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08186: return false;
08187: if (jj_3R_143())
08188: return true;
08189: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08190: return false;
08191: return false;
08192: }
08193:
08194: final private boolean jj_3_18() {
08195: Token xsp;
08196: xsp = jj_scanpos;
08197: if (jj_3R_65()) {
08198: jj_scanpos = xsp;
08199: if (jj_3R_66())
08200: return true;
08201: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08202: return false;
08203: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08204: return false;
08205: if (jj_scan_token(END))
08206: return true;
08207: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08208: return false;
08209: if (jj_3R_143())
08210: return true;
08211: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08212: return false;
08213: return false;
08214: }
08215:
08216: final private boolean jj_3R_227() {
08217: if (jj_3R_129())
08218: return true;
08219: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08220: return false;
08221: return false;
08222: }
08223:
08224: final private boolean jj_3R_226() {
08225: if (jj_3R_128())
08226: return true;
08227: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08228: return false;
08229: return false;
08230: }
08231:
08232: final private boolean jj_3R_318() {
08233: if (jj_scan_token(OPEN))
08234: return true;
08235: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08236: return false;
08237: if (jj_3R_74())
08238: return true;
08239: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08240: return false;
08241: if (jj_scan_token(CLOSE))
08242: return true;
08243: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08244: return false;
08245: if (jj_3R_143())
08246: return true;
08247: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08248: return false;
08249: return false;
08250: }
08251:
08252: final private boolean jj_3R_160() {
08253: if (jj_3R_74())
08254: return true;
08255: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08256: return false;
08257: return false;
08258: }
08259:
08260: final private boolean jj_3_13() {
08261: if (jj_3R_59())
08262: return true;
08263: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08264: return false;
08265: return false;
08266: }
08267:
08268: final private boolean jj_3_17() {
08269: if (jj_scan_token(OPEN))
08270: return true;
08271: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08272: return false;
08273: if (jj_scan_token(CLOSE))
08274: return true;
08275: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08276: return false;
08277: if (jj_3R_143())
08278: return true;
08279: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08280: return false;
08281: return false;
08282: }
08283:
08284: final private boolean jj_3R_126() {
08285: if (jj_scan_token(TRY))
08286: return true;
08287: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08288: return false;
08289: if (jj_3R_52())
08290: return true;
08291: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08292: return false;
08293: Token xsp;
08294: while (true) {
08295: xsp = jj_scanpos;
08296: if (jj_3R_226()) {
08297: jj_scanpos = xsp;
08298: break;
08299: }
08300: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08301: return false;
08302: }
08303: xsp = jj_scanpos;
08304: if (jj_3R_227())
08305: jj_scanpos = xsp;
08306: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08307: return false;
08308: return false;
08309: }
08310:
08311: final private boolean jj_3R_380() {
08312: if (jj_scan_token(MODULE))
08313: return true;
08314: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08315: return false;
08316: return false;
08317: }
08318:
08319: final private boolean jj_3R_371() {
08320: if (jj_scan_token(OPEN))
08321: return true;
08322: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08323: return false;
08324: if (jj_3R_101())
08325: return true;
08326: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08327: return false;
08328: if (jj_scan_token(CLOSE))
08329: return true;
08330: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08331: return false;
08332: return false;
08333: }
08334:
08335: final private boolean jj_3R_150() {
08336: if (jj_3R_177())
08337: return true;
08338: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08339: return false;
08340: return false;
08341: }
08342:
08343: final private boolean jj_3R_149() {
08344: if (jj_3R_59())
08345: return true;
08346: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08347: return false;
08348: return false;
08349: }
08350:
08351: final private boolean jj_3_1() {
08352: if (jj_scan_token(DOT))
08353: return true;
08354: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08355: return false;
08356: if (jj_scan_token(SYMBOL))
08357: return true;
08358: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08359: return false;
08360: return false;
08361: }
08362:
08363: final private boolean jj_3R_98() {
08364: if (jj_3R_52())
08365: return true;
08366: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08367: return false;
08368: return false;
08369: }
08370:
08371: final private boolean jj_3R_116() {
08372: Token xsp;
08373: xsp = jj_scanpos;
08374: if (jj_3R_149()) {
08375: jj_scanpos = xsp;
08376: if (jj_3R_150())
08377: return true;
08378: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08379: return false;
08380: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08381: return false;
08382: return false;
08383: }
08384:
08385: final private boolean jj_3R_379() {
08386: if (jj_scan_token(SYMBOL))
08387: return true;
08388: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08389: return false;
08390: return false;
08391: }
08392:
08393: final private boolean jj_3R_369() {
08394: if (jj_scan_token(OPEN))
08395: return true;
08396: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08397: return false;
08398: if (jj_3R_101())
08399: return true;
08400: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08401: return false;
08402: if (jj_scan_token(CLOSE))
08403: return true;
08404: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08405: return false;
08406: return false;
08407: }
08408:
08409: final private boolean jj_3R_317() {
08410: if (jj_scan_token(DELETE))
08411: return true;
08412: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08413: return false;
08414: Token xsp;
08415: xsp = jj_scanpos;
08416: if (jj_3R_371()) {
08417: jj_scanpos = xsp;
08418: if (jj_3R_372())
08419: return true;
08420: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08421: return false;
08422: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08423: return false;
08424: return false;
08425: }
08426:
08427: final private boolean jj_3R_373() {
08428: Token xsp;
08429: xsp = jj_scanpos;
08430: if (jj_3R_379()) {
08431: jj_scanpos = xsp;
08432: if (jj_3R_380())
08433: return true;
08434: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08435: return false;
08436: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08437: return false;
08438: while (true) {
08439: xsp = jj_scanpos;
08440: if (jj_3_1()) {
08441: jj_scanpos = xsp;
08442: break;
08443: }
08444: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08445: return false;
08446: }
08447: return false;
08448: }
08449:
08450: final private boolean jj_3R_55() {
08451: if (jj_scan_token(BEGIN))
08452: return true;
08453: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08454: return false;
08455: Token xsp;
08456: while (true) {
08457: xsp = jj_scanpos;
08458: if (jj_3R_98()) {
08459: jj_scanpos = xsp;
08460: break;
08461: }
08462: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08463: return false;
08464: }
08465: if (jj_scan_token(END))
08466: return true;
08467: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08468: return false;
08469: return false;
08470: }
08471:
08472: final private boolean jj_3R_316() {
08473: if (jj_scan_token(DEFINED))
08474: return true;
08475: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08476: return false;
08477: Token xsp;
08478: xsp = jj_scanpos;
08479: if (jj_3R_369()) {
08480: jj_scanpos = xsp;
08481: if (jj_3R_370())
08482: return true;
08483: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08484: return false;
08485: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08486: return false;
08487: return false;
08488: }
08489:
08490: final private boolean jj_3R_315() {
08491: if (jj_scan_token(IMPORT))
08492: return true;
08493: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08494: return false;
08495: if (jj_scan_token(OPEN))
08496: return true;
08497: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08498: return false;
08499: if (jj_3R_60())
08500: return true;
08501: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08502: return false;
08503: if (jj_scan_token(CLOSE))
08504: return true;
08505: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08506: return false;
08507: if (jj_3R_143())
08508: return true;
08509: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08510: return false;
08511: return false;
08512: }
08513:
08514: final private boolean jj_3R_183() {
08515: if (jj_scan_token(SEMICOLON))
08516: return true;
08517: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08518: return false;
08519: return false;
08520: }
08521:
08522: final private boolean jj_3R_314() {
08523: if (jj_3R_332())
08524: return true;
08525: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08526: return false;
08527: if (jj_3R_143())
08528: return true;
08529: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08530: return false;
08531: return false;
08532: }
08533:
08534: final private boolean jj_3R_312() {
08535: Token xsp;
08536: xsp = jj_scanpos;
08537: if (jj_3R_314()) {
08538: jj_scanpos = xsp;
08539: if (jj_3R_315()) {
08540: jj_scanpos = xsp;
08541: if (jj_3R_316()) {
08542: jj_scanpos = xsp;
08543: if (jj_3R_317()) {
08544: jj_scanpos = xsp;
08545: if (jj_3_17()) {
08546: jj_scanpos = xsp;
08547: if (jj_3R_318()) {
08548: jj_scanpos = xsp;
08549: if (jj_3_18()) {
08550: jj_scanpos = xsp;
08551: if (jj_3R_319()) {
08552: jj_scanpos = xsp;
08553: if (jj_3R_320()) {
08554: jj_scanpos = xsp;
08555: if (jj_3R_321()) {
08556: jj_scanpos = xsp;
08557: if (jj_3R_322()) {
08558: jj_scanpos = xsp;
08559: if (jj_3R_323()) {
08560: jj_scanpos = xsp;
08561: if (jj_3R_324()) {
08562: jj_scanpos = xsp;
08563: if (jj_3R_325()) {
08564: jj_scanpos = xsp;
08565: if (jj_3R_326()) {
08566: jj_scanpos = xsp;
08567: if (jj_3R_327()) {
08568: jj_scanpos = xsp;
08569: if (jj_3R_328())
08570: return true;
08571: if (jj_la == 0
08572: && jj_scanpos == jj_lastpos)
08573: return false;
08574: } else if (jj_la == 0
08575: && jj_scanpos == jj_lastpos)
08576: return false;
08577: } else if (jj_la == 0
08578: && jj_scanpos == jj_lastpos)
08579: return false;
08580: } else if (jj_la == 0
08581: && jj_scanpos == jj_lastpos)
08582: return false;
08583: } else if (jj_la == 0
08584: && jj_scanpos == jj_lastpos)
08585: return false;
08586: } else if (jj_la == 0
08587: && jj_scanpos == jj_lastpos)
08588: return false;
08589: } else if (jj_la == 0
08590: && jj_scanpos == jj_lastpos)
08591: return false;
08592: } else if (jj_la == 0
08593: && jj_scanpos == jj_lastpos)
08594: return false;
08595: } else if (jj_la == 0
08596: && jj_scanpos == jj_lastpos)
08597: return false;
08598: } else if (jj_la == 0
08599: && jj_scanpos == jj_lastpos)
08600: return false;
08601: } else if (jj_la == 0
08602: && jj_scanpos == jj_lastpos)
08603: return false;
08604: } else if (jj_la == 0
08605: && jj_scanpos == jj_lastpos)
08606: return false;
08607: } else if (jj_la == 0
08608: && jj_scanpos == jj_lastpos)
08609: return false;
08610: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08611: return false;
08612: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08613: return false;
08614: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08615: return false;
08616: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08617: return false;
08618: return false;
08619: }
08620:
08621: final private boolean jj_3R_182() {
08622: if (jj_scan_token(WHILE))
08623: return true;
08624: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08625: return false;
08626: if (jj_3R_116())
08627: return true;
08628: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08629: return false;
08630: if (jj_scan_token(SEMICOLON))
08631: return true;
08632: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08633: return false;
08634: return false;
08635: }
08636:
08637: final private boolean jj_3R_181() {
08638: if (jj_scan_token(IF))
08639: return true;
08640: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08641: return false;
08642: if (jj_3R_116())
08643: return true;
08644: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08645: return false;
08646: if (jj_scan_token(SEMICOLON))
08647: return true;
08648: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08649: return false;
08650: return false;
08651: }
08652:
08653: final private boolean jj_3R_155() {
08654: Token xsp;
08655: xsp = jj_scanpos;
08656: if (jj_3R_181()) {
08657: jj_scanpos = xsp;
08658: if (jj_3R_182()) {
08659: jj_scanpos = xsp;
08660: if (jj_3R_183())
08661: return true;
08662: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08663: return false;
08664: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08665: return false;
08666: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08667: return false;
08668: return false;
08669: }
08670:
08671: final private boolean jj_3R_95() {
08672: if (jj_3R_137())
08673: return true;
08674: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08675: return false;
08676: return false;
08677: }
08678:
08679: final private boolean jj_3_7() {
08680: if (jj_3R_55())
08681: return true;
08682: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08683: return false;
08684: return false;
08685: }
08686:
08687: final private boolean jj_3R_221() {
08688: if (jj_3R_55())
08689: return true;
08690: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08691: return false;
08692: return false;
08693: }
08694:
08695: final private boolean jj_3R_220() {
08696: if (jj_3R_136())
08697: return true;
08698: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08699: return false;
08700: return false;
08701: }
08702:
08703: final private boolean jj_3R_219() {
08704: if (jj_3R_135())
08705: return true;
08706: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08707: return false;
08708: return false;
08709: }
08710:
08711: final private boolean jj_3R_218() {
08712: if (jj_3R_134())
08713: return true;
08714: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08715: return false;
08716: return false;
08717: }
08718:
08719: final private boolean jj_3R_217() {
08720: if (jj_3R_133())
08721: return true;
08722: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08723: return false;
08724: return false;
08725: }
08726:
08727: final private boolean jj_3R_311() {
08728: if (jj_scan_token(CARET))
08729: return true;
08730: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08731: return false;
08732: return false;
08733: }
08734:
08735: final private boolean jj_3R_216() {
08736: if (jj_3R_132())
08737: return true;
08738: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08739: return false;
08740: return false;
08741: }
08742:
08743: final private boolean jj_3R_310() {
08744: Token xsp;
08745: xsp = jj_scanpos;
08746: if (jj_3R_311())
08747: jj_scanpos = xsp;
08748: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08749: return false;
08750: if (jj_3R_312())
08751: return true;
08752: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08753: return false;
08754: return false;
08755: }
08756:
08757: final private boolean jj_3_6() {
08758: if (jj_3R_54())
08759: return true;
08760: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08761: return false;
08762: Token xsp;
08763: xsp = jj_scanpos;
08764: if (jj_3R_216()) {
08765: jj_scanpos = xsp;
08766: if (jj_3R_217()) {
08767: jj_scanpos = xsp;
08768: if (jj_3R_218()) {
08769: jj_scanpos = xsp;
08770: if (jj_3R_219()) {
08771: jj_scanpos = xsp;
08772: if (jj_3R_220()) {
08773: jj_scanpos = xsp;
08774: if (jj_3R_221())
08775: return true;
08776: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08777: return false;
08778: } else if (jj_la == 0
08779: && jj_scanpos == jj_lastpos)
08780: return false;
08781: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08782: return false;
08783: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08784: return false;
08785: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08786: return false;
08787: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08788: return false;
08789: return false;
08790: }
08791:
08792: final private boolean jj_3R_94() {
08793: if (jj_3R_136())
08794: return true;
08795: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08796: return false;
08797: return false;
08798: }
08799:
08800: final private boolean jj_3R_93() {
08801: if (jj_3R_135())
08802: return true;
08803: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08804: return false;
08805: return false;
08806: }
08807:
08808: final private boolean jj_3R_92() {
08809: if (jj_3R_134())
08810: return true;
08811: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08812: return false;
08813: return false;
08814: }
08815:
08816: final private boolean jj_3R_91() {
08817: if (jj_3R_133())
08818: return true;
08819: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08820: return false;
08821: return false;
08822: }
08823:
08824: final private boolean jj_3R_90() {
08825: if (jj_3R_132())
08826: return true;
08827: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08828: return false;
08829: return false;
08830: }
08831:
08832: final private boolean jj_3R_89() {
08833: if (jj_3R_131())
08834: return true;
08835: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08836: return false;
08837: return false;
08838: }
08839:
08840: final private boolean jj_3R_88() {
08841: if (jj_3R_130())
08842: return true;
08843: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08844: return false;
08845: return false;
08846: }
08847:
08848: final private boolean jj_3R_87() {
08849: if (jj_3R_129())
08850: return true;
08851: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08852: return false;
08853: return false;
08854: }
08855:
08856: final private boolean jj_3R_86() {
08857: if (jj_3R_128())
08858: return true;
08859: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08860: return false;
08861: return false;
08862: }
08863:
08864: final private boolean jj_3R_85() {
08865: if (jj_3R_127())
08866: return true;
08867: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08868: return false;
08869: return false;
08870: }
08871:
08872: final private boolean jj_3R_84() {
08873: if (jj_3R_126())
08874: return true;
08875: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08876: return false;
08877: return false;
08878: }
08879:
08880: final private boolean jj_3R_83() {
08881: if (jj_3R_125())
08882: return true;
08883: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08884: return false;
08885: return false;
08886: }
08887:
08888: final private boolean jj_3R_82() {
08889: if (jj_3R_124())
08890: return true;
08891: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08892: return false;
08893: return false;
08894: }
08895:
08896: final private boolean jj_3R_81() {
08897: if (jj_3R_123())
08898: return true;
08899: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08900: return false;
08901: return false;
08902: }
08903:
08904: final private boolean jj_3R_80() {
08905: if (jj_3R_122())
08906: return true;
08907: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08908: return false;
08909: return false;
08910: }
08911:
08912: final private boolean jj_3R_79() {
08913: if (jj_3R_121())
08914: return true;
08915: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08916: return false;
08917: return false;
08918: }
08919:
08920: final private boolean jj_3R_78() {
08921: if (jj_3R_120())
08922: return true;
08923: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08924: return false;
08925: return false;
08926: }
08927:
08928: final private boolean jj_3R_77() {
08929: if (jj_3R_119())
08930: return true;
08931: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08932: return false;
08933: return false;
08934: }
08935:
08936: final private boolean jj_3R_367() {
08937: if (jj_scan_token(OPEN))
08938: return true;
08939: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08940: return false;
08941: if (jj_3R_60())
08942: return true;
08943: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08944: return false;
08945: if (jj_scan_token(CLOSE))
08946: return true;
08947: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08948: return false;
08949: return false;
08950: }
08951:
08952: final private boolean jj_3R_76() {
08953: if (jj_3R_118())
08954: return true;
08955: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08956: return false;
08957: return false;
08958: }
08959:
08960: final private boolean jj_3R_366() {
08961: if (jj_scan_token(SYMBOL))
08962: return true;
08963: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08964: return false;
08965: return false;
08966: }
08967:
08968: final private boolean jj_3R_365() {
08969: if (jj_scan_token(NEGATION))
08970: return true;
08971: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08972: return false;
08973: return false;
08974: }
08975:
08976: final private boolean jj_3R_337() {
08977: if (jj_scan_token(HAS))
08978: return true;
08979: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08980: return false;
08981: Token xsp;
08982: xsp = jj_scanpos;
08983: if (jj_3R_365())
08984: jj_scanpos = xsp;
08985: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08986: return false;
08987: xsp = jj_scanpos;
08988: if (jj_3R_366()) {
08989: jj_scanpos = xsp;
08990: if (jj_3R_367())
08991: return true;
08992: if (jj_la == 0 && jj_scanpos == jj_lastpos)
08993: return false;
08994: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
08995: return false;
08996: return false;
08997: }
08998:
08999: final private boolean jj_3R_52() {
09000: Token xsp;
09001: xsp = jj_scanpos;
09002: if (jj_3R_76()) {
09003: jj_scanpos = xsp;
09004: if (jj_3R_77()) {
09005: jj_scanpos = xsp;
09006: if (jj_3R_78()) {
09007: jj_scanpos = xsp;
09008: if (jj_3R_79()) {
09009: jj_scanpos = xsp;
09010: if (jj_3R_80()) {
09011: jj_scanpos = xsp;
09012: if (jj_3R_81()) {
09013: jj_scanpos = xsp;
09014: if (jj_3R_82()) {
09015: jj_scanpos = xsp;
09016: if (jj_3R_83()) {
09017: jj_scanpos = xsp;
09018: if (jj_3R_84()) {
09019: jj_scanpos = xsp;
09020: if (jj_3R_85()) {
09021: jj_scanpos = xsp;
09022: if (jj_3R_86()) {
09023: jj_scanpos = xsp;
09024: if (jj_3R_87()) {
09025: jj_scanpos = xsp;
09026: if (jj_3R_88()) {
09027: jj_scanpos = xsp;
09028: if (jj_3R_89()) {
09029: jj_scanpos = xsp;
09030: if (jj_3R_90()) {
09031: jj_scanpos = xsp;
09032: if (jj_3R_91()) {
09033: jj_scanpos = xsp;
09034: if (jj_3R_92()) {
09035: jj_scanpos = xsp;
09036: if (jj_3R_93()) {
09037: jj_scanpos = xsp;
09038: if (jj_3R_94()) {
09039: jj_scanpos = xsp;
09040: if (jj_3_6()) {
09041: jj_scanpos = xsp;
09042: if (jj_3_7()) {
09043: jj_scanpos = xsp;
09044: if (jj_3R_95())
09045: return true;
09046: if (jj_la == 0
09047: && jj_scanpos == jj_lastpos)
09048: return false;
09049: } else if (jj_la == 0
09050: && jj_scanpos == jj_lastpos)
09051: return false;
09052: } else if (jj_la == 0
09053: && jj_scanpos == jj_lastpos)
09054: return false;
09055: } else if (jj_la == 0
09056: && jj_scanpos == jj_lastpos)
09057: return false;
09058: } else if (jj_la == 0
09059: && jj_scanpos == jj_lastpos)
09060: return false;
09061: } else if (jj_la == 0
09062: && jj_scanpos == jj_lastpos)
09063: return false;
09064: } else if (jj_la == 0
09065: && jj_scanpos == jj_lastpos)
09066: return false;
09067: } else if (jj_la == 0
09068: && jj_scanpos == jj_lastpos)
09069: return false;
09070: } else if (jj_la == 0
09071: && jj_scanpos == jj_lastpos)
09072: return false;
09073: } else if (jj_la == 0
09074: && jj_scanpos == jj_lastpos)
09075: return false;
09076: } else if (jj_la == 0
09077: && jj_scanpos == jj_lastpos)
09078: return false;
09079: } else if (jj_la == 0
09080: && jj_scanpos == jj_lastpos)
09081: return false;
09082: } else if (jj_la == 0
09083: && jj_scanpos == jj_lastpos)
09084: return false;
09085: } else if (jj_la == 0
09086: && jj_scanpos == jj_lastpos)
09087: return false;
09088: } else if (jj_la == 0
09089: && jj_scanpos == jj_lastpos)
09090: return false;
09091: } else if (jj_la == 0
09092: && jj_scanpos == jj_lastpos)
09093: return false;
09094: } else if (jj_la == 0
09095: && jj_scanpos == jj_lastpos)
09096: return false;
09097: } else if (jj_la == 0
09098: && jj_scanpos == jj_lastpos)
09099: return false;
09100: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09101: return false;
09102: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09103: return false;
09104: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09105: return false;
09106: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09107: return false;
09108: return false;
09109: }
09110:
09111: final private boolean jj_3R_125() {
09112: if (jj_scan_token(ASSERT))
09113: return true;
09114: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09115: return false;
09116: if (jj_3R_116())
09117: return true;
09118: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09119: return false;
09120: if (jj_scan_token(SEMICOLON))
09121: return true;
09122: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09123: return false;
09124: return false;
09125: }
09126:
09127: final private boolean jj_3R_364() {
09128: if (jj_3R_373())
09129: return true;
09130: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09131: return false;
09132: return false;
09133: }
09134:
09135: final private boolean jj_3R_363() {
09136: if (jj_scan_token(ET))
09137: return true;
09138: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09139: return false;
09140: return false;
09141: }
09142:
09143: final private boolean jj_3R_362() {
09144: if (jj_scan_token(CLASS))
09145: return true;
09146: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09147: return false;
09148: return false;
09149: }
09150:
09151: final private boolean jj_3R_123() {
09152: if (jj_scan_token(YIELD))
09153: return true;
09154: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09155: return false;
09156: if (jj_3R_160())
09157: return true;
09158: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09159: return false;
09160: if (jj_3R_155())
09161: return true;
09162: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09163: return false;
09164: return false;
09165: }
09166:
09167: final private boolean jj_3R_361() {
09168: if (jj_scan_token(OPEN_BRACKET))
09169: return true;
09170: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09171: return false;
09172: if (jj_scan_token(CLOSE_BRACKET))
09173: return true;
09174: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09175: return false;
09176: return false;
09177: }
09178:
09179: final private boolean jj_3R_360() {
09180: if (jj_scan_token(BEGIN))
09181: return true;
09182: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09183: return false;
09184: if (jj_scan_token(END))
09185: return true;
09186: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09187: return false;
09188: return false;
09189: }
09190:
09191: final private boolean jj_3R_359() {
09192: if (jj_scan_token(OPEN))
09193: return true;
09194: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09195: return false;
09196: if (jj_scan_token(CLOSE))
09197: return true;
09198: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09199: return false;
09200: return false;
09201: }
09202:
09203: final private boolean jj_3R_358() {
09204: if (jj_scan_token(MAP))
09205: return true;
09206: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09207: return false;
09208: return false;
09209: }
09210:
09211: final private boolean jj_3R_357() {
09212: if (jj_scan_token(RANGE))
09213: return true;
09214: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09215: return false;
09216: return false;
09217: }
09218:
09219: final private boolean jj_3R_356() {
09220: if (jj_scan_token(STRING))
09221: return true;
09222: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09223: return false;
09224: return false;
09225: }
09226:
09227: final private boolean jj_3R_355() {
09228: if (jj_scan_token(FLOAT))
09229: return true;
09230: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09231: return false;
09232: return false;
09233: }
09234:
09235: final private boolean jj_3R_159() {
09236: if (jj_3R_160())
09237: return true;
09238: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09239: return false;
09240: return false;
09241: }
09242:
09243: final private boolean jj_3R_354() {
09244: if (jj_scan_token(INT))
09245: return true;
09246: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09247: return false;
09248: return false;
09249: }
09250:
09251: final private boolean jj_3R_122() {
09252: if (jj_scan_token(RETURN))
09253: return true;
09254: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09255: return false;
09256: Token xsp;
09257: xsp = jj_scanpos;
09258: if (jj_3R_159())
09259: jj_scanpos = xsp;
09260: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09261: return false;
09262: if (jj_3R_155())
09263: return true;
09264: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09265: return false;
09266: return false;
09267: }
09268:
09269: final private boolean jj_3R_353() {
09270: if (jj_scan_token(BOOLEAN))
09271: return true;
09272: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09273: return false;
09274: return false;
09275: }
09276:
09277: final private boolean jj_3R_161() {
09278: if (jj_3R_160())
09279: return true;
09280: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09281: return false;
09282: return false;
09283: }
09284:
09285: final private boolean jj_3R_352() {
09286: if (jj_scan_token(NULL))
09287: return true;
09288: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09289: return false;
09290: return false;
09291: }
09292:
09293: final private boolean jj_3R_351() {
09294: if (jj_scan_token(UNDEFINED))
09295: return true;
09296: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09297: return false;
09298: return false;
09299: }
09300:
09301: final private boolean jj_3R_64() {
09302: if (jj_scan_token(STRING))
09303: return true;
09304: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09305: return false;
09306: return false;
09307: }
09308:
09309: final private boolean jj_3R_350() {
09310: if (jj_scan_token(DEFINED))
09311: return true;
09312: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09313: return false;
09314: return false;
09315: }
09316:
09317: final private boolean jj_3R_349() {
09318: if (jj_scan_token(NEGATION))
09319: return true;
09320: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09321: return false;
09322: return false;
09323: }
09324:
09325: final private boolean jj_3R_124() {
09326: if (jj_scan_token(EXIT))
09327: return true;
09328: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09329: return false;
09330: Token xsp;
09331: xsp = jj_scanpos;
09332: if (jj_3R_161())
09333: jj_scanpos = xsp;
09334: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09335: return false;
09336: if (jj_3R_155())
09337: return true;
09338: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09339: return false;
09340: return false;
09341: }
09342:
09343: final private boolean jj_3R_307() {
09344: if (jj_3R_310())
09345: return true;
09346: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09347: return false;
09348: Token xsp;
09349: while (true) {
09350: xsp = jj_scanpos;
09351: if (jj_3R_329()) {
09352: jj_scanpos = xsp;
09353: break;
09354: }
09355: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09356: return false;
09357: }
09358: return false;
09359: }
09360:
09361: final private boolean jj_3R_336() {
09362: if (jj_scan_token(IS))
09363: return true;
09364: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09365: return false;
09366: Token xsp;
09367: xsp = jj_scanpos;
09368: if (jj_3R_349())
09369: jj_scanpos = xsp;
09370: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09371: return false;
09372: xsp = jj_scanpos;
09373: if (jj_3R_350()) {
09374: jj_scanpos = xsp;
09375: if (jj_3R_351()) {
09376: jj_scanpos = xsp;
09377: if (jj_3R_352()) {
09378: jj_scanpos = xsp;
09379: if (jj_3R_353()) {
09380: jj_scanpos = xsp;
09381: if (jj_3R_354()) {
09382: jj_scanpos = xsp;
09383: if (jj_3R_355()) {
09384: jj_scanpos = xsp;
09385: if (jj_3R_356()) {
09386: jj_scanpos = xsp;
09387: if (jj_3R_357()) {
09388: jj_scanpos = xsp;
09389: if (jj_3R_358()) {
09390: jj_scanpos = xsp;
09391: if (jj_3R_359()) {
09392: jj_scanpos = xsp;
09393: if (jj_3R_360()) {
09394: jj_scanpos = xsp;
09395: if (jj_3R_361()) {
09396: jj_scanpos = xsp;
09397: if (jj_3R_362()) {
09398: jj_scanpos = xsp;
09399: if (jj_3R_363()) {
09400: jj_scanpos = xsp;
09401: if (jj_3R_364())
09402: return true;
09403: if (jj_la == 0
09404: && jj_scanpos == jj_lastpos)
09405: return false;
09406: } else if (jj_la == 0
09407: && jj_scanpos == jj_lastpos)
09408: return false;
09409: } else if (jj_la == 0
09410: && jj_scanpos == jj_lastpos)
09411: return false;
09412: } else if (jj_la == 0
09413: && jj_scanpos == jj_lastpos)
09414: return false;
09415: } else if (jj_la == 0
09416: && jj_scanpos == jj_lastpos)
09417: return false;
09418: } else if (jj_la == 0
09419: && jj_scanpos == jj_lastpos)
09420: return false;
09421: } else if (jj_la == 0
09422: && jj_scanpos == jj_lastpos)
09423: return false;
09424: } else if (jj_la == 0
09425: && jj_scanpos == jj_lastpos)
09426: return false;
09427: } else if (jj_la == 0
09428: && jj_scanpos == jj_lastpos)
09429: return false;
09430: } else if (jj_la == 0
09431: && jj_scanpos == jj_lastpos)
09432: return false;
09433: } else if (jj_la == 0
09434: && jj_scanpos == jj_lastpos)
09435: return false;
09436: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09437: return false;
09438: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09439: return false;
09440: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09441: return false;
09442: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09443: return false;
09444: return false;
09445: }
09446:
09447: final private boolean jj_3R_329() {
09448: Token xsp;
09449: xsp = jj_scanpos;
09450: if (jj_3R_336()) {
09451: jj_scanpos = xsp;
09452: if (jj_3R_337())
09453: return true;
09454: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09455: return false;
09456: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09457: return false;
09458: return false;
09459: }
09460:
09461: final private boolean jj_3R_63() {
09462: if (jj_scan_token(FLOAT))
09463: return true;
09464: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09465: return false;
09466: return false;
09467: }
09468:
09469: final private boolean jj_3R_97() {
09470: if (jj_scan_token(SYMBOL))
09471: return true;
09472: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09473: return false;
09474: return false;
09475: }
09476:
09477: final private boolean jj_3R_330() {
09478: if (jj_scan_token(PLUSPLUS))
09479: return true;
09480: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09481: return false;
09482: return false;
09483: }
09484:
09485: final private boolean jj_3R_313() {
09486: Token xsp;
09487: xsp = jj_scanpos;
09488: if (jj_3R_330()) {
09489: jj_scanpos = xsp;
09490: if (jj_3R_331())
09491: return true;
09492: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09493: return false;
09494: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09495: return false;
09496: return false;
09497: }
09498:
09499: final private boolean jj_3R_62() {
09500: if (jj_scan_token(INT))
09501: return true;
09502: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09503: return false;
09504: return false;
09505: }
09506:
09507: final private boolean jj_3R_331() {
09508: if (jj_scan_token(MINUSMINUS))
09509: return true;
09510: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09511: return false;
09512: return false;
09513: }
09514:
09515: final private boolean jj_3R_157() {
09516: if (jj_scan_token(SYMBOL))
09517: return true;
09518: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09519: return false;
09520: return false;
09521: }
09522:
09523: final private boolean jj_3R_302() {
09524: if (jj_3R_307())
09525: return true;
09526: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09527: return false;
09528: Token xsp;
09529: while (true) {
09530: xsp = jj_scanpos;
09531: if (jj_3R_313()) {
09532: jj_scanpos = xsp;
09533: break;
09534: }
09535: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09536: return false;
09537: }
09538: return false;
09539: }
09540:
09541: final private boolean jj_3R_185() {
09542: if (jj_scan_token(_DEFAULT))
09543: return true;
09544: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09545: return false;
09546: return false;
09547: }
09548:
09549: final private boolean jj_3R_61() {
09550: if (jj_scan_token(BOOLEAN))
09551: return true;
09552: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09553: return false;
09554: return false;
09555: }
09556:
09557: final private boolean jj_3R_96() {
09558: if (jj_scan_token(STATIC))
09559: return true;
09560: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09561: return false;
09562: return false;
09563: }
09564:
09565: final private boolean jj_3R_184() {
09566: if (jj_scan_token(CASE))
09567: return true;
09568: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09569: return false;
09570: if (jj_3R_177())
09571: return true;
09572: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09573: return false;
09574: return false;
09575: }
09576:
09577: final private boolean jj_3R_297() {
09578: if (jj_3R_302())
09579: return true;
09580: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09581: return false;
09582: return false;
09583: }
09584:
09585: final private boolean jj_3R_53() {
09586: Token xsp;
09587: xsp = jj_scanpos;
09588: if (jj_3R_96())
09589: jj_scanpos = xsp;
09590: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09591: return false;
09592: if (jj_scan_token(VAR))
09593: return true;
09594: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09595: return false;
09596: if (jj_3R_97())
09597: return true;
09598: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09599: return false;
09600: return false;
09601: }
09602:
09603: final private boolean jj_3R_158() {
09604: Token xsp;
09605: xsp = jj_scanpos;
09606: if (jj_3R_184()) {
09607: jj_scanpos = xsp;
09608: if (jj_3R_185())
09609: return true;
09610: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09611: return false;
09612: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09613: return false;
09614: return false;
09615: }
09616:
09617: final private boolean jj_3R_121() {
09618: if (jj_scan_token(CONTINUE))
09619: return true;
09620: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09621: return false;
09622: Token xsp;
09623: xsp = jj_scanpos;
09624: if (jj_3R_157())
09625: jj_scanpos = xsp;
09626: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09627: return false;
09628: xsp = jj_scanpos;
09629: if (jj_3R_158())
09630: jj_scanpos = xsp;
09631: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09632: return false;
09633: if (jj_3R_155())
09634: return true;
09635: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09636: return false;
09637: return false;
09638: }
09639:
09640: final private boolean jj_3_5() {
09641: if (jj_3R_53())
09642: return true;
09643: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09644: return false;
09645: return false;
09646: }
09647:
09648: final private boolean jj_3_16() {
09649: if (jj_scan_token(OPEN))
09650: return true;
09651: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09652: return false;
09653: Token xsp;
09654: xsp = jj_scanpos;
09655: if (jj_3R_61()) {
09656: jj_scanpos = xsp;
09657: if (jj_3R_62()) {
09658: jj_scanpos = xsp;
09659: if (jj_3R_63()) {
09660: jj_scanpos = xsp;
09661: if (jj_3R_64())
09662: return true;
09663: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09664: return false;
09665: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09666: return false;
09667: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09668: return false;
09669: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09670: return false;
09671: if (jj_scan_token(CLOSE))
09672: return true;
09673: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09674: return false;
09675: if (jj_3R_283())
09676: return true;
09677: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09678: return false;
09679: return false;
09680: }
09681:
09682: final private boolean jj_3R_296() {
09683: if (jj_scan_token(CLASSOF))
09684: return true;
09685: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09686: return false;
09687: if (jj_3R_283())
09688: return true;
09689: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09690: return false;
09691: return false;
09692: }
09693:
09694: final private boolean jj_3R_156() {
09695: if (jj_scan_token(SYMBOL))
09696: return true;
09697: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09698: return false;
09699: return false;
09700: }
09701:
09702: final private boolean jj_3R_295() {
09703: if (jj_scan_token(SIZEOF))
09704: return true;
09705: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09706: return false;
09707: if (jj_3R_283())
09708: return true;
09709: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09710: return false;
09711: return false;
09712: }
09713:
09714: final private boolean jj_3R_294() {
09715: if (jj_scan_token(TYPEOF))
09716: return true;
09717: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09718: return false;
09719: if (jj_3R_283())
09720: return true;
09721: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09722: return false;
09723: return false;
09724: }
09725:
09726: final private boolean jj_3R_120() {
09727: if (jj_scan_token(BREAK))
09728: return true;
09729: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09730: return false;
09731: Token xsp;
09732: xsp = jj_scanpos;
09733: if (jj_3R_156())
09734: jj_scanpos = xsp;
09735: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09736: return false;
09737: if (jj_3R_155())
09738: return true;
09739: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09740: return false;
09741: return false;
09742: }
09743:
09744: final private boolean jj_3R_293() {
09745: if (jj_scan_token(CLONEOF))
09746: return true;
09747: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09748: return false;
09749: if (jj_3R_283())
09750: return true;
09751: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09752: return false;
09753: return false;
09754: }
09755:
09756: final private boolean jj_3R_291() {
09757: if (jj_scan_token(PLUSPLUS))
09758: return true;
09759: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09760: return false;
09761: if (jj_3R_283())
09762: return true;
09763: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09764: return false;
09765: return false;
09766: }
09767:
09768: final private boolean jj_3R_292() {
09769: if (jj_scan_token(COPYOF))
09770: return true;
09771: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09772: return false;
09773: if (jj_3R_283())
09774: return true;
09775: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09776: return false;
09777: return false;
09778: }
09779:
09780: final private boolean jj_3R_290() {
09781: if (jj_scan_token(MINUSMINUS))
09782: return true;
09783: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09784: return false;
09785: if (jj_3R_283())
09786: return true;
09787: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09788: return false;
09789: return false;
09790: }
09791:
09792: final private boolean jj_3R_289() {
09793: if (jj_scan_token(STAR))
09794: return true;
09795: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09796: return false;
09797: if (jj_3R_283())
09798: return true;
09799: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09800: return false;
09801: return false;
09802: }
09803:
09804: final private boolean jj_3R_58() {
09805: if (jj_3R_99())
09806: return true;
09807: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09808: return false;
09809: return false;
09810: }
09811:
09812: final private boolean jj_3_12() {
09813: Token xsp;
09814: xsp = jj_scanpos;
09815: if (jj_3R_58())
09816: jj_scanpos = xsp;
09817: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09818: return false;
09819: if (jj_scan_token(SEMICOLON))
09820: return true;
09821: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09822: return false;
09823: return false;
09824: }
09825:
09826: final private boolean jj_3R_346() {
09827: if (jj_scan_token(PATTERN))
09828: return true;
09829: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09830: return false;
09831: return false;
09832: }
09833:
09834: final private boolean jj_3R_57() {
09835: if (jj_3R_99())
09836: return true;
09837: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09838: return false;
09839: return false;
09840: }
09841:
09842: final private boolean jj_3R_345() {
09843: if (jj_scan_token(UNDEFINED))
09844: return true;
09845: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09846: return false;
09847: return false;
09848: }
09849:
09850: final private boolean jj_3_11() {
09851: Token xsp;
09852: xsp = jj_scanpos;
09853: if (jj_3R_57())
09854: jj_scanpos = xsp;
09855: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09856: return false;
09857: if (jj_scan_token(SEMICOLON))
09858: return true;
09859: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09860: return false;
09861: return false;
09862: }
09863:
09864: final private boolean jj_3R_56() {
09865: if (jj_3R_99())
09866: return true;
09867: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09868: return false;
09869: return false;
09870: }
09871:
09872: final private boolean jj_3R_255() {
09873: if (jj_3R_99())
09874: return true;
09875: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09876: return false;
09877: return false;
09878: }
09879:
09880: final private boolean jj_3R_288() {
09881: if (jj_scan_token(MINUS))
09882: return true;
09883: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09884: return false;
09885: if (jj_3R_283())
09886: return true;
09887: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09888: return false;
09889: return false;
09890: }
09891:
09892: final private boolean jj_3R_344() {
09893: if (jj_scan_token(NULL))
09894: return true;
09895: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09896: return false;
09897: return false;
09898: }
09899:
09900: final private boolean jj_3_10() {
09901: Token xsp;
09902: xsp = jj_scanpos;
09903: if (jj_3R_56())
09904: jj_scanpos = xsp;
09905: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09906: return false;
09907: if (jj_scan_token(SEMICOLON))
09908: return true;
09909: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09910: return false;
09911: return false;
09912: }
09913:
09914: final private boolean jj_3R_309() {
09915: if (jj_scan_token(NO_MATCH))
09916: return true;
09917: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09918: return false;
09919: return false;
09920: }
09921:
09922: final private boolean jj_3R_242() {
09923: Token xsp;
09924: xsp = jj_scanpos;
09925: if (jj_3R_255())
09926: jj_scanpos = xsp;
09927: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09928: return false;
09929: if (jj_scan_token(SEMICOLON))
09930: return true;
09931: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09932: return false;
09933: return false;
09934: }
09935:
09936: final private boolean jj_3R_254() {
09937: if (jj_3R_99())
09938: return true;
09939: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09940: return false;
09941: return false;
09942: }
09943:
09944: final private boolean jj_3R_343() {
09945: if (jj_scan_token(TRUE))
09946: return true;
09947: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09948: return false;
09949: return false;
09950: }
09951:
09952: final private boolean jj_3R_241() {
09953: Token xsp;
09954: xsp = jj_scanpos;
09955: if (jj_3R_254())
09956: jj_scanpos = xsp;
09957: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
09958: return false;
09959: if (jj_scan_token(SEMICOLON))
09960: return true;
09961: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09962: return false;
09963: return false;
09964: }
09965:
09966: final private boolean jj_3R_253() {
09967: if (jj_3R_99())
09968: return true;
09969: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09970: return false;
09971: return false;
09972: }
09973:
09974: final private boolean jj_3R_342() {
09975: if (jj_scan_token(FALSE))
09976: return true;
09977: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09978: return false;
09979: return false;
09980: }
09981:
09982: final private boolean jj_3R_286() {
09983: if (jj_scan_token(NEGATION))
09984: return true;
09985: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09986: return false;
09987: if (jj_3R_283())
09988: return true;
09989: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09990: return false;
09991: return false;
09992: }
09993:
09994: final private boolean jj_3R_240() {
09995: Token xsp;
09996: xsp = jj_scanpos;
09997: if (jj_3R_253())
09998: jj_scanpos = xsp;
09999: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10000: return false;
10001: if (jj_scan_token(SEMICOLON))
10002: return true;
10003: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10004: return false;
10005: return false;
10006: }
10007:
10008: final private boolean jj_3R_287() {
10009: if (jj_scan_token(PLUS))
10010: return true;
10011: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10012: return false;
10013: if (jj_3R_283())
10014: return true;
10015: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10016: return false;
10017: return false;
10018: }
10019:
10020: final private boolean jj_3R_283() {
10021: Token xsp;
10022: xsp = jj_scanpos;
10023: if (jj_3R_286()) {
10024: jj_scanpos = xsp;
10025: if (jj_3R_287()) {
10026: jj_scanpos = xsp;
10027: if (jj_3R_288()) {
10028: jj_scanpos = xsp;
10029: if (jj_3R_289()) {
10030: jj_scanpos = xsp;
10031: if (jj_3R_290()) {
10032: jj_scanpos = xsp;
10033: if (jj_3R_291()) {
10034: jj_scanpos = xsp;
10035: if (jj_3R_292()) {
10036: jj_scanpos = xsp;
10037: if (jj_3R_293()) {
10038: jj_scanpos = xsp;
10039: if (jj_3R_294()) {
10040: jj_scanpos = xsp;
10041: if (jj_3R_295()) {
10042: jj_scanpos = xsp;
10043: if (jj_3R_296()) {
10044: jj_scanpos = xsp;
10045: if (jj_3_16()) {
10046: jj_scanpos = xsp;
10047: if (jj_3R_297())
10048: return true;
10049: if (jj_la == 0
10050: && jj_scanpos == jj_lastpos)
10051: return false;
10052: } else if (jj_la == 0
10053: && jj_scanpos == jj_lastpos)
10054: return false;
10055: } else if (jj_la == 0
10056: && jj_scanpos == jj_lastpos)
10057: return false;
10058: } else if (jj_la == 0
10059: && jj_scanpos == jj_lastpos)
10060: return false;
10061: } else if (jj_la == 0
10062: && jj_scanpos == jj_lastpos)
10063: return false;
10064: } else if (jj_la == 0
10065: && jj_scanpos == jj_lastpos)
10066: return false;
10067: } else if (jj_la == 0
10068: && jj_scanpos == jj_lastpos)
10069: return false;
10070: } else if (jj_la == 0
10071: && jj_scanpos == jj_lastpos)
10072: return false;
10073: } else if (jj_la == 0
10074: && jj_scanpos == jj_lastpos)
10075: return false;
10076: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10077: return false;
10078: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10079: return false;
10080: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10081: return false;
10082: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10083: return false;
10084: return false;
10085: }
10086:
10087: final private boolean jj_3R_341() {
10088: if (jj_scan_token(INF))
10089: return true;
10090: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10091: return false;
10092: return false;
10093: }
10094:
10095: final private boolean jj_3R_308() {
10096: if (jj_scan_token(MATCH))
10097: return true;
10098: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10099: return false;
10100: return false;
10101: }
10102:
10103: final private boolean jj_3R_303() {
10104: Token xsp;
10105: xsp = jj_scanpos;
10106: if (jj_3R_308()) {
10107: jj_scanpos = xsp;
10108: if (jj_3R_309())
10109: return true;
10110: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10111: return false;
10112: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10113: return false;
10114: if (jj_3R_283())
10115: return true;
10116: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10117: return false;
10118: return false;
10119: }
10120:
10121: final private boolean jj_3R_162() {
10122: if (jj_scan_token(FOREACH))
10123: return true;
10124: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10125: return false;
10126: if (jj_scan_token(OPEN))
10127: return true;
10128: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10129: return false;
10130: Token xsp;
10131: xsp = jj_scanpos;
10132: if (jj_3R_240())
10133: jj_scanpos = xsp;
10134: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10135: return false;
10136: xsp = jj_scanpos;
10137: if (jj_3R_241())
10138: jj_scanpos = xsp;
10139: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10140: return false;
10141: xsp = jj_scanpos;
10142: if (jj_3R_242())
10143: jj_scanpos = xsp;
10144: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10145: return false;
10146: if (jj_3R_116())
10147: return true;
10148: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10149: return false;
10150: if (jj_scan_token(CLOSE))
10151: return true;
10152: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10153: return false;
10154: return false;
10155: }
10156:
10157: final private boolean jj_3R_306() {
10158: if (jj_scan_token(REMAINDER))
10159: return true;
10160: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10161: return false;
10162: return false;
10163: }
10164:
10165: final private boolean jj_3R_368() {
10166: if (jj_scan_token(STRING_LITERAL))
10167: return true;
10168: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10169: return false;
10170: return false;
10171: }
10172:
10173: final private boolean jj_3R_340() {
10174: Token xsp;
10175: if (jj_3R_368())
10176: return true;
10177: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10178: return false;
10179: while (true) {
10180: xsp = jj_scanpos;
10181: if (jj_3R_368()) {
10182: jj_scanpos = xsp;
10183: break;
10184: }
10185: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10186: return false;
10187: }
10188: return false;
10189: }
10190:
10191: final private boolean jj_3R_301() {
10192: if (jj_scan_token(ET))
10193: return true;
10194: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10195: return false;
10196: return false;
10197: }
10198:
10199: final private boolean jj_3R_305() {
10200: if (jj_scan_token(SLASH))
10201: return true;
10202: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10203: return false;
10204: return false;
10205: }
10206:
10207: final private boolean jj_3R_339() {
10208: if (jj_scan_token(FLOATING_POINT_LITERAL))
10209: return true;
10210: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10211: return false;
10212: return false;
10213: }
10214:
10215: final private boolean jj_3R_139() {
10216: if (jj_scan_token(COMMA))
10217: return true;
10218: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10219: return false;
10220: if (jj_3R_138())
10221: return true;
10222: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10223: return false;
10224: return false;
10225: }
10226:
10227: final private boolean jj_3R_277() {
10228: if (jj_3R_283())
10229: return true;
10230: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10231: return false;
10232: Token xsp;
10233: while (true) {
10234: xsp = jj_scanpos;
10235: if (jj_3R_303()) {
10236: jj_scanpos = xsp;
10237: break;
10238: }
10239: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10240: return false;
10241: }
10242: return false;
10243: }
10244:
10245: final private boolean jj_3R_338() {
10246: if (jj_scan_token(INTEGER_LITERAL))
10247: return true;
10248: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10249: return false;
10250: return false;
10251: }
10252:
10253: final private boolean jj_3R_99() {
10254: if (jj_3R_138())
10255: return true;
10256: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10257: return false;
10258: Token xsp;
10259: while (true) {
10260: xsp = jj_scanpos;
10261: if (jj_3R_139()) {
10262: jj_scanpos = xsp;
10263: break;
10264: }
10265: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10266: return false;
10267: }
10268: return false;
10269: }
10270:
10271: final private boolean jj_3R_332() {
10272: Token xsp;
10273: xsp = jj_scanpos;
10274: if (jj_3R_338()) {
10275: jj_scanpos = xsp;
10276: if (jj_3R_339()) {
10277: jj_scanpos = xsp;
10278: if (jj_3R_340()) {
10279: jj_scanpos = xsp;
10280: if (jj_3R_341()) {
10281: jj_scanpos = xsp;
10282: if (jj_3R_342()) {
10283: jj_scanpos = xsp;
10284: if (jj_3R_343()) {
10285: jj_scanpos = xsp;
10286: if (jj_3R_344()) {
10287: jj_scanpos = xsp;
10288: if (jj_3R_345()) {
10289: jj_scanpos = xsp;
10290: if (jj_3R_346())
10291: return true;
10292: if (jj_la == 0
10293: && jj_scanpos == jj_lastpos)
10294: return false;
10295: } else if (jj_la == 0
10296: && jj_scanpos == jj_lastpos)
10297: return false;
10298: } else if (jj_la == 0
10299: && jj_scanpos == jj_lastpos)
10300: return false;
10301: } else if (jj_la == 0
10302: && jj_scanpos == jj_lastpos)
10303: return false;
10304: } else if (jj_la == 0
10305: && jj_scanpos == jj_lastpos)
10306: return false;
10307: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10308: return false;
10309: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10310: return false;
10311: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10312: return false;
10313: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10314: return false;
10315: return false;
10316: }
10317:
10318: final private boolean jj_3R_304() {
10319: if (jj_scan_token(STAR))
10320: return true;
10321: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10322: return false;
10323: return false;
10324: }
10325:
10326: final private boolean jj_3R_298() {
10327: Token xsp;
10328: xsp = jj_scanpos;
10329: if (jj_3R_304()) {
10330: jj_scanpos = xsp;
10331: if (jj_3R_305()) {
10332: jj_scanpos = xsp;
10333: if (jj_3R_306())
10334: return true;
10335: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10336: return false;
10337: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10338: return false;
10339: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10340: return false;
10341: if (jj_3R_277())
10342: return true;
10343: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10344: return false;
10345: return false;
10346: }
10347:
10348: final private boolean jj_3R_300() {
10349: if (jj_scan_token(MINUS))
10350: return true;
10351: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10352: return false;
10353: return false;
10354: }
10355:
10356: final private boolean jj_3R_146() {
10357: if (jj_3R_176())
10358: return true;
10359: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10360: return false;
10361: Token xsp;
10362: while (true) {
10363: xsp = jj_scanpos;
10364: if (jj_3R_204()) {
10365: jj_scanpos = xsp;
10366: break;
10367: }
10368: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10369: return false;
10370: }
10371: return false;
10372: }
10373:
10374: final private boolean jj_3R_114() {
10375: Token xsp;
10376: xsp = jj_scanpos;
10377: if (jj_3R_146())
10378: jj_scanpos = xsp;
10379: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10380: return false;
10381: return false;
10382: }
10383:
10384: final private boolean jj_3R_204() {
10385: if (jj_scan_token(COMMA))
10386: return true;
10387: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10388: return false;
10389: if (jj_3R_176())
10390: return true;
10391: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10392: return false;
10393: return false;
10394: }
10395:
10396: final private boolean jj_3R_135() {
10397: if (jj_3R_162())
10398: return true;
10399: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10400: return false;
10401: if (jj_3R_52())
10402: return true;
10403: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10404: return false;
10405: return false;
10406: }
10407:
10408: final private boolean jj_3R_299() {
10409: if (jj_scan_token(PLUS))
10410: return true;
10411: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10412: return false;
10413: return false;
10414: }
10415:
10416: final private boolean jj_3R_284() {
10417: Token xsp;
10418: xsp = jj_scanpos;
10419: if (jj_3R_299()) {
10420: jj_scanpos = xsp;
10421: if (jj_3R_300()) {
10422: jj_scanpos = xsp;
10423: if (jj_3R_301())
10424: return true;
10425: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10426: return false;
10427: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10428: return false;
10429: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10430: return false;
10431: if (jj_3R_269())
10432: return true;
10433: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10434: return false;
10435: return false;
10436: }
10437:
10438: final private boolean jj_3R_384() {
10439: if (jj_scan_token(COMMA))
10440: return true;
10441: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10442: return false;
10443: return false;
10444: }
10445:
10446: final private boolean jj_3R_194() {
10447: if (jj_3R_52())
10448: return true;
10449: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10450: return false;
10451: return false;
10452: }
10453:
10454: final private boolean jj_3R_269() {
10455: if (jj_3R_277())
10456: return true;
10457: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10458: return false;
10459: Token xsp;
10460: while (true) {
10461: xsp = jj_scanpos;
10462: if (jj_3R_298()) {
10463: jj_scanpos = xsp;
10464: break;
10465: }
10466: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10467: return false;
10468: }
10469: return false;
10470: }
10471:
10472: final private boolean jj_3R_193() {
10473: if (jj_3R_60())
10474: return true;
10475: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10476: return false;
10477: return false;
10478: }
10479:
10480: final private boolean jj_3_27() {
10481: if (jj_scan_token(SYMBOL))
10482: return true;
10483: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10484: return false;
10485: if (jj_scan_token(ASSIGN))
10486: return true;
10487: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10488: return false;
10489: if (jj_3R_60())
10490: return true;
10491: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10492: return false;
10493: return false;
10494: }
10495:
10496: final private boolean jj_3R_134() {
10497: if (jj_scan_token(DO))
10498: return true;
10499: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10500: return false;
10501: if (jj_3R_52())
10502: return true;
10503: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10504: return false;
10505: if (jj_scan_token(WHILE))
10506: return true;
10507: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10508: return false;
10509: if (jj_scan_token(OPEN))
10510: return true;
10511: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10512: return false;
10513: if (jj_3R_116())
10514: return true;
10515: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10516: return false;
10517: if (jj_scan_token(CLOSE))
10518: return true;
10519: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10520: return false;
10521: if (jj_scan_token(SEMICOLON))
10522: return true;
10523: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10524: return false;
10525: return false;
10526: }
10527:
10528: final private boolean jj_3R_192() {
10529: if (jj_scan_token(AT))
10530: return true;
10531: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10532: return false;
10533: if (jj_3R_60())
10534: return true;
10535: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10536: return false;
10537: return false;
10538: }
10539:
10540: final private boolean jj_3R_176() {
10541: Token xsp;
10542: xsp = jj_scanpos;
10543: if (jj_3R_192()) {
10544: jj_scanpos = xsp;
10545: if (jj_3_27()) {
10546: jj_scanpos = xsp;
10547: if (jj_3R_193())
10548: return true;
10549: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10550: return false;
10551: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10552: return false;
10553: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10554: return false;
10555: return false;
10556: }
10557:
10558: final private boolean jj_3R_285() {
10559: if (jj_scan_token(NEGATION))
10560: return true;
10561: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10562: return false;
10563: return false;
10564: }
10565:
10566: final private boolean jj_3R_278() {
10567: Token xsp;
10568: xsp = jj_scanpos;
10569: if (jj_3R_285())
10570: jj_scanpos = xsp;
10571: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10572: return false;
10573: if (jj_scan_token(IN))
10574: return true;
10575: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10576: return false;
10577: if (jj_3R_267())
10578: return true;
10579: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10580: return false;
10581: return false;
10582: }
10583:
10584: final private boolean jj_3R_148() {
10585: if (jj_scan_token(BOOLEAN_OR))
10586: return true;
10587: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10588: return false;
10589: return false;
10590: }
10591:
10592: final private boolean jj_3R_147() {
10593: if (jj_scan_token(PIPE))
10594: return true;
10595: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10596: return false;
10597: if (jj_3R_205())
10598: return true;
10599: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10600: return false;
10601: if (jj_scan_token(PIPE))
10602: return true;
10603: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10604: return false;
10605: return false;
10606: }
10607:
10608: final private boolean jj_3R_267() {
10609: if (jj_3R_269())
10610: return true;
10611: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10612: return false;
10613: Token xsp;
10614: while (true) {
10615: xsp = jj_scanpos;
10616: if (jj_3R_284()) {
10617: jj_scanpos = xsp;
10618: break;
10619: }
10620: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10621: return false;
10622: }
10623: return false;
10624: }
10625:
10626: final private boolean jj_3R_115() {
10627: if (jj_scan_token(BEGIN))
10628: return true;
10629: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10630: return false;
10631: Token xsp;
10632: xsp = jj_scanpos;
10633: if (jj_3R_147()) {
10634: jj_scanpos = xsp;
10635: if (jj_3R_148())
10636: return true;
10637: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10638: return false;
10639: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10640: return false;
10641: while (true) {
10642: xsp = jj_scanpos;
10643: if (jj_3R_194()) {
10644: jj_scanpos = xsp;
10645: break;
10646: }
10647: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10648: return false;
10649: }
10650: if (jj_scan_token(END))
10651: return true;
10652: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10653: return false;
10654: return false;
10655: }
10656:
10657: final private boolean jj_3R_117() {
10658: if (jj_3R_60())
10659: return true;
10660: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10661: return false;
10662: return false;
10663: }
10664:
10665: final private boolean jj_3_26() {
10666: if (jj_scan_token(SYMBOL))
10667: return true;
10668: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10669: return false;
10670: if (jj_scan_token(ASSIGN))
10671: return true;
10672: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10673: return false;
10674: if (jj_3R_60())
10675: return true;
10676: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10677: return false;
10678: return false;
10679: }
10680:
10681: final private boolean jj_3R_75() {
10682: Token xsp;
10683: xsp = jj_scanpos;
10684: if (jj_3_26()) {
10685: jj_scanpos = xsp;
10686: if (jj_3R_117())
10687: return true;
10688: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10689: return false;
10690: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10691: return false;
10692: return false;
10693: }
10694:
10695: final private boolean jj_3R_133() {
10696: if (jj_scan_token(FOR))
10697: return true;
10698: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10699: return false;
10700: if (jj_scan_token(OPEN))
10701: return true;
10702: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10703: return false;
10704: if (jj_3R_230())
10705: return true;
10706: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10707: return false;
10708: if (jj_scan_token(CLOSE))
10709: return true;
10710: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10711: return false;
10712: if (jj_3R_52())
10713: return true;
10714: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10715: return false;
10716: return false;
10717: }
10718:
10719: final private boolean jj_3_4() {
10720: if (jj_3R_52())
10721: return true;
10722: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10723: return false;
10724: return false;
10725: }
10726:
10727: final private boolean jj_3R_264() {
10728: if (jj_3R_267())
10729: return true;
10730: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10731: return false;
10732: Token xsp;
10733: while (true) {
10734: xsp = jj_scanpos;
10735: if (jj_3R_278()) {
10736: jj_scanpos = xsp;
10737: break;
10738: }
10739: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10740: return false;
10741: }
10742: return false;
10743: }
10744:
10745: final private boolean jj_3_25() {
10746: if (jj_scan_token(COMMA))
10747: return true;
10748: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10749: return false;
10750: if (jj_3R_75())
10751: return true;
10752: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10753: return false;
10754: return false;
10755: }
10756:
10757: final private boolean jj_3R_382() {
10758: if (jj_3R_75())
10759: return true;
10760: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10761: return false;
10762: Token xsp;
10763: while (true) {
10764: xsp = jj_scanpos;
10765: if (jj_3_25()) {
10766: jj_scanpos = xsp;
10767: break;
10768: }
10769: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10770: return false;
10771: }
10772: xsp = jj_scanpos;
10773: if (jj_3R_384())
10774: jj_scanpos = xsp;
10775: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10776: return false;
10777: return false;
10778: }
10779:
10780: final private boolean jj_3R_252() {
10781: if (jj_scan_token(COMMA))
10782: return true;
10783: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10784: return false;
10785: if (jj_3R_250())
10786: return true;
10787: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10788: return false;
10789: return false;
10790: }
10791:
10792: final private boolean jj_3R_282() {
10793: if (jj_scan_token(GREATER_OR_EQUAL))
10794: return true;
10795: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10796: return false;
10797: return false;
10798: }
10799:
10800: final private boolean jj_3R_381() {
10801: if (jj_3R_383())
10802: return true;
10803: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10804: return false;
10805: return false;
10806: }
10807:
10808: final private boolean jj_3R_239() {
10809: if (jj_3R_250())
10810: return true;
10811: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10812: return false;
10813: Token xsp;
10814: while (true) {
10815: xsp = jj_scanpos;
10816: if (jj_3R_252()) {
10817: jj_scanpos = xsp;
10818: break;
10819: }
10820: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10821: return false;
10822: }
10823: return false;
10824: }
10825:
10826: final private boolean jj_3R_374() {
10827: Token xsp;
10828: xsp = jj_scanpos;
10829: if (jj_3R_381()) {
10830: jj_scanpos = xsp;
10831: if (jj_3R_382())
10832: return true;
10833: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10834: return false;
10835: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10836: return false;
10837: return false;
10838: }
10839:
10840: final private boolean jj_3R_238() {
10841: if (jj_3R_116())
10842: return true;
10843: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10844: return false;
10845: return false;
10846: }
10847:
10848: final private boolean jj_3R_333() {
10849: if (jj_scan_token(OPEN_BRACKET))
10850: return true;
10851: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10852: return false;
10853: Token xsp;
10854: xsp = jj_scanpos;
10855: if (jj_3R_374())
10856: jj_scanpos = xsp;
10857: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10858: return false;
10859: if (jj_scan_token(CLOSE_BRACKET))
10860: return true;
10861: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10862: return false;
10863: return false;
10864: }
10865:
10866: final private boolean jj_3R_251() {
10867: if (jj_scan_token(COMMA))
10868: return true;
10869: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10870: return false;
10871: if (jj_3R_250())
10872: return true;
10873: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10874: return false;
10875: return false;
10876: }
10877:
10878: final private boolean jj_3R_237() {
10879: if (jj_3R_250())
10880: return true;
10881: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10882: return false;
10883: Token xsp;
10884: while (true) {
10885: xsp = jj_scanpos;
10886: if (jj_3R_251()) {
10887: jj_scanpos = xsp;
10888: break;
10889: }
10890: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10891: return false;
10892: }
10893: return false;
10894: }
10895:
10896: final private boolean jj_3R_281() {
10897: if (jj_scan_token(LESS_OR_EQUAL))
10898: return true;
10899: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10900: return false;
10901: return false;
10902: }
10903:
10904: final private boolean jj_3R_378() {
10905: if (jj_3R_74())
10906: return true;
10907: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10908: return false;
10909: return false;
10910: }
10911:
10912: final private boolean jj_3R_348() {
10913: if (jj_scan_token(BEGIN_LIST))
10914: return true;
10915: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10916: return false;
10917: return false;
10918: }
10919:
10920: final private boolean jj_3R_230() {
10921: Token xsp;
10922: xsp = jj_scanpos;
10923: if (jj_3R_237())
10924: jj_scanpos = xsp;
10925: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10926: return false;
10927: if (jj_scan_token(SEMICOLON))
10928: return true;
10929: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10930: return false;
10931: xsp = jj_scanpos;
10932: if (jj_3R_238())
10933: jj_scanpos = xsp;
10934: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10935: return false;
10936: if (jj_scan_token(SEMICOLON))
10937: return true;
10938: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10939: return false;
10940: xsp = jj_scanpos;
10941: if (jj_3R_239())
10942: jj_scanpos = xsp;
10943: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10944: return false;
10945: return false;
10946: }
10947:
10948: final private boolean jj_3R_377() {
10949: if (jj_3R_383())
10950: return true;
10951: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10952: return false;
10953: return false;
10954: }
10955:
10956: final private boolean jj_3R_347() {
10957: if (jj_scan_token(BEGIN))
10958: return true;
10959: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10960: return false;
10961: return false;
10962: }
10963:
10964: final private boolean jj_3R_280() {
10965: if (jj_scan_token(GREATER))
10966: return true;
10967: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10968: return false;
10969: return false;
10970: }
10971:
10972: final private boolean jj_3R_335() {
10973: Token xsp;
10974: xsp = jj_scanpos;
10975: if (jj_3R_347()) {
10976: jj_scanpos = xsp;
10977: if (jj_3R_348())
10978: return true;
10979: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10980: return false;
10981: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10982: return false;
10983: xsp = jj_scanpos;
10984: if (jj_3R_377()) {
10985: jj_scanpos = xsp;
10986: if (jj_3R_378())
10987: return true;
10988: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10989: return false;
10990: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
10991: return false;
10992: if (jj_scan_token(END))
10993: return true;
10994: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10995: return false;
10996: return false;
10997: }
10998:
10999: public TokenManager token_source;
11000: public Token token, jj_nt;
11001: private int jj_ntk;
11002: private Token jj_scanpos, jj_lastpos;
11003: private int jj_la;
11004: public boolean lookingAhead = false;
11005: private boolean jj_semLA;
11006: private int jj_gen;
11007: final private int[] jj_la1 = new int[157];
11008: final private int[] jj_la1_0 = { 0x35310420, 0x4, 0x35310420,
11009: 0x35310420, 0x2, 0x40, 0x35310420, 0x6, 0xc0, 0xc0, 0x200,
11010: 0xc0, 0xc0, 0x106, 0x1080, 0x1080, 0x106, 0x10c0, 0x10c0,
11011: 0x806, 0x4000, 0x200, 0x8004, 0x8004, 0x80000, 0x100000,
11012: 0xd43bad4e, 0x110400, 0x200000, 0x100000, 0x310000,
11013: 0xd43bad4e, 0x310400, 0xc00000, 0xd43bad4e, 0x200,
11014: 0x2000000, 0x21210400, 0x21210400, 0x2000000, 0x8000000,
11015: 0x34310400, 0x24000400, 0x310000, 0x200000, 0x200, 0x4000,
11016: 0x200, 0xd43bad4e, 0x80000008, 0xc0102000, 0x142b8d4e,
11017: 0xc0002000, 0xd43bad4e, 0x200, 0x1000, 0x200, 0x200, 0x200,
11018: 0x142b8d4e, 0x142b8d4e, 0x0, 0x0, 0x0, 0x200, 0xd43bad4e,
11019: 0xd43bad4e, 0x0, 0x200, 0x142b8d4e, 0x142b8d4e, 0x200,
11020: 0x142b8d4e, 0x200, 0x14290046, 0x14290046, 0x14290046, 0x4,
11021: 0x4, 0x0, 0x0, 0x142b8d4e, 0x142b8d4e, 0x142b8d4e, 0x0,
11022: 0x200, 0x0, 0x4000, 0x0, 0x0, 0x0, 0x142b8d4e, 0x0, 0x0,
11023: 0x142b0d4e, 0x142b0d4e, 0x8000, 0x142b8d4e, 0x800000, 0x0,
11024: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x100, 0x100,
11025: 0x0, 0x0, 0x0, 0x100, 0x142b0c4e, 0x0, 0x0, 0x0, 0x0,
11026: 0x402800e, 0x0, 0x20004, 0x0, 0x0, 0x142b0046, 0x142b0046,
11027: 0x8, 0xc00, 0x20000, 0x0, 0x1429004e, 0x20008, 0x4,
11028: 0x10000000, 0x14290006, 0x14290046, 0x20008, 0x20048,
11029: 0x20008, 0x20008, 0x4020004, 0x20048, 0x0, 0x542b8d4e, 0x8,
11030: 0x142b8d4e, 0x200, 0x142b8d4e, 0x142b8d4e, 0x142b8d4e, 0x0,
11031: 0x142b8d4e, 0x200, 0x142b8d4e, 0x800, 0x800, };
11032: final private int[] jj_la1_1 = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11033: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11034: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3ff2ff, 0x0, 0x0, 0x0,
11035: 0x0, 0x3ff2ff, 0x0, 0x0, 0x3ff2ff, 0x0, 0x0, 0x0, 0x0, 0x0,
11036: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3ff2ff, 0x7200,
11037: 0x1ff2ff, 0x200000, 0x0, 0x3ff2ff, 0x0, 0x0, 0x0, 0x0, 0x0,
11038: 0x200000, 0x200000, 0xf0, 0x100, 0xc00, 0x0, 0x3ff2ff,
11039: 0x3ff2ff, 0xc00, 0x0, 0x200000, 0x200000, 0x0, 0x200000,
11040: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc00, 0xc00, 0x200000,
11041: 0x200000, 0x200000, 0x200000, 0x0, 0x200000, 0x1fc00000,
11042: 0x4000, 0x20000000, 0x40000000, 0x200000, 0x80000020,
11043: 0x80000020, 0x200000, 0x200000, 0x0, 0x200000, 0x0, 0x0,
11044: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x200000, 0x200000, 0x0,
11045: 0x0, 0x0, 0x0, 0x0, 0x0, 0x200000, 0x0, 0x0, 0x0, 0x0,
11046: 0x40200000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11047: 0x0, 0x200000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11048: 0x0, 0x0, 0x0, 0x204000, 0x0, 0x204000, 0x0, 0x204000,
11049: 0x204000, 0x200000, 0x0, 0x200000, 0x0, 0x200000, 0x0, 0x0, };
11050: final private int[] jj_la1_2 = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11051: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11052: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7ff0d000, 0x0, 0x0,
11053: 0x0, 0x0, 0x7ff0d000, 0x0, 0x0, 0x7ff0d000, 0x0, 0x0, 0x0,
11054: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11055: 0x7ff0d000, 0x0, 0x0, 0x7ff0d000, 0x0, 0x7ff0d000, 0x0,
11056: 0x0, 0x0, 0x0, 0x0, 0x7ff0d000, 0x7ff0d000, 0x0, 0x0, 0x0,
11057: 0x0, 0x7ff0d000, 0x7ff0d000, 0x0, 0x0, 0x7ff0d000,
11058: 0x7ff0d000, 0x0, 0x7ff0d000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11059: 0x0, 0x0, 0x7ff0d000, 0x7ff0d000, 0x7ff0d000, 0x0, 0x0,
11060: 0x0, 0x0, 0x0, 0x0, 0x0, 0x7ff0d000, 0x0, 0x0, 0x7ff0d000,
11061: 0x7ff0d000, 0x0, 0x7ff0d000, 0x0, 0x1, 0x2, 0xfc, 0xfc,
11062: 0xf00, 0xf00, 0x3000, 0x1000, 0xc000, 0xc000, 0x30000,
11063: 0x30000, 0xc0000, 0xc0000, 0x78000000, 0x7f0d000,
11064: 0x78000000, 0x300000, 0x300000, 0x80000000, 0x1000,
11065: 0x78000000, 0x1000, 0x0, 0x80000000, 0x0, 0x0, 0x0, 0x0,
11066: 0x0, 0x0, 0x0, 0x78000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11067: 0x0, 0x0, 0x0, 0x3c00000, 0x0, 0x0, 0x7ff0d000, 0x0,
11068: 0x7ff0d000, 0x0, 0x7ff0d000, 0x7ff0d000, 0x7ff0d000, 0x0,
11069: 0x7ff0d000, 0x0, 0x7ff0d000, 0x0, 0x0, };
11070: final private int[] jj_la1_3 = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11071: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11072: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f7cf, 0x0, 0x0, 0x0,
11073: 0x0, 0x3f7cf, 0x0, 0x0, 0x3f7cf, 0x0, 0x0, 0x0, 0x0, 0x0,
11074: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f7cf, 0x0, 0x0,
11075: 0x3f7cf, 0x0, 0x3f7cf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f7cf,
11076: 0x3f7cf, 0x0, 0x0, 0x0, 0x0, 0x3f7cf, 0x3f7cf, 0x0, 0x0,
11077: 0x3f7cf, 0x3f7cf, 0x0, 0x3f7cf, 0x0, 0x400, 0x400, 0x400,
11078: 0x0, 0x0, 0x0, 0x0, 0x3f7cf, 0x3f7cf, 0x3f7cf, 0x0, 0x0,
11079: 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f7cf, 0x0, 0x0, 0x3f7cf,
11080: 0x3f7cf, 0x0, 0x3f7cf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
11081: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3f7cf,
11082: 0x0, 0x0, 0x20, 0x0, 0xf, 0x0, 0x0, 0x20, 0x40, 0x400,
11083: 0x400, 0x100, 0x3f087, 0x0, 0x208, 0x500, 0x0, 0x400, 0x0,
11084: 0x400, 0x400, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x8, 0x3f7cf,
11085: 0x100, 0x3f7cf, 0x0, 0x3f7cf, 0x3f7cf, 0x3f7cf, 0x800,
11086: 0x3f7cf, 0x0, 0x3ffcf, 0x0, 0x3f006, };
11087: final private JJCalls[] jj_2_rtns = new JJCalls[27];
11088: private boolean jj_rescan = false;
11089: private int jj_gc = 0;
11090:
11091: public ParserBase(TokenManager tm) {
11092: token_source = tm;
11093: token = new Token();
11094: jj_ntk = -1;
11095: jj_gen = 0;
11096: for (int i = 0; i < 157; i++)
11097: jj_la1[i] = -1;
11098: for (int i = 0; i < jj_2_rtns.length; i++)
11099: jj_2_rtns[i] = new JJCalls();
11100: }
11101:
11102: public void ReInit(TokenManager tm) {
11103: token_source = tm;
11104: token = new Token();
11105: jj_ntk = -1;
11106: jj_gen = 0;
11107: for (int i = 0; i < 157; i++)
11108: jj_la1[i] = -1;
11109: for (int i = 0; i < jj_2_rtns.length; i++)
11110: jj_2_rtns[i] = new JJCalls();
11111: }
11112:
11113: final private Token jj_consume_token(int kind)
11114: throws ParseException {
11115: Token oldToken;
11116: if ((oldToken = token).next != null)
11117: token = token.next;
11118: else
11119: token = token.next = token_source.getNextToken();
11120: jj_ntk = -1;
11121: if (token.kind == kind) {
11122: jj_gen++;
11123: if (++jj_gc > 100) {
11124: jj_gc = 0;
11125: for (int i = 0; i < jj_2_rtns.length; i++) {
11126: JJCalls c = jj_2_rtns[i];
11127: while (c != null) {
11128: if (c.gen < jj_gen)
11129: c.first = null;
11130: c = c.next;
11131: }
11132: }
11133: }
11134: return token;
11135: }
11136: token = oldToken;
11137: jj_kind = kind;
11138: throw generateParseException();
11139: }
11140:
11141: final private boolean jj_scan_token(int kind) {
11142: if (jj_scanpos == jj_lastpos) {
11143: jj_la--;
11144: if (jj_scanpos.next == null) {
11145: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
11146: .getNextToken();
11147: } else {
11148: jj_lastpos = jj_scanpos = jj_scanpos.next;
11149: }
11150: } else {
11151: jj_scanpos = jj_scanpos.next;
11152: }
11153: if (jj_rescan) {
11154: int i = 0;
11155: Token tok = token;
11156: while (tok != null && tok != jj_scanpos) {
11157: i++;
11158: tok = tok.next;
11159: }
11160: if (tok != null)
11161: jj_add_error_token(kind, i);
11162: }
11163: return (jj_scanpos.kind != kind);
11164: }
11165:
11166: final public Token getNextToken() {
11167: if (token.next != null)
11168: token = token.next;
11169: else
11170: token = token.next = token_source.getNextToken();
11171: jj_ntk = -1;
11172: jj_gen++;
11173: return token;
11174: }
11175:
11176: final public Token getToken(int index) {
11177: Token t = lookingAhead ? jj_scanpos : token;
11178: for (int i = 0; i < index; i++) {
11179: if (t.next != null)
11180: t = t.next;
11181: else
11182: t = t.next = token_source.getNextToken();
11183: }
11184: return t;
11185: }
11186:
11187: final private int jj_ntk() {
11188: if ((jj_nt = token.next) == null)
11189: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
11190: else
11191: return (jj_ntk = jj_nt.kind);
11192: }
11193:
11194: private java.util.Vector jj_expentries = new java.util.Vector();
11195: private int[] jj_expentry;
11196: private int jj_kind = -1;
11197: private int[] jj_lasttokens = new int[100];
11198: private int jj_endpos;
11199:
11200: private void jj_add_error_token(int kind, int pos) {
11201: if (pos >= 100) return;
11202: if (pos == jj_endpos + 1) {
11203: jj_lasttokens[jj_endpos++] = kind;
11204: } else if (jj_endpos != 0) {
11205: jj_expentry = new int[jj_endpos];
11206: for (int i = 0; i < jj_endpos; i++) {
11207: jj_expentry[i] = jj_lasttokens[i];
11208: }
11209: boolean exists = false;
11210: for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
11211: int[] oldentry = (int[])(enum.nextElement());
11212: if (oldentry.length == jj_expentry.length) {
11213: exists = true;
11214: for (int i = 0; i < jj_expentry.length; i++) {
11215: if (oldentry[i] != jj_expentry[i]) {
11216: exists = false;
11217: break;
11218: }
11219: }
11220: if (exists) break;
11221: }
11222: }
11223: if (!exists) jj_expentries.addElement(jj_expentry);
11224: if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
11225: }
11226: }
11227:
11228: final public ParseException generateParseException() {
11229: jj_expentries.removeAllElements();
11230: boolean[] la1tokens = new boolean[114];
11231: for (int i = 0; i < 114; i++) {
11232: la1tokens[i] = false;
11233: }
11234: if (jj_kind >= 0) {
11235: la1tokens[jj_kind] = true;
11236: jj_kind = -1;
11237: }
11238: for (int i = 0; i < 157; i++) {
11239: if (jj_la1[i] == jj_gen) {
11240: for (int j = 0; j < 32; j++) {
11241: if ((jj_la1_0[i] & (1 << j)) != 0) {
11242: la1tokens[j] = true;
11243: }
11244: if ((jj_la1_1[i] & (1 << j)) != 0) {
11245: la1tokens[32 + j] = true;
11246: }
11247: if ((jj_la1_2[i] & (1 << j)) != 0) {
11248: la1tokens[64 + j] = true;
11249: }
11250: if ((jj_la1_3[i] & (1 << j)) != 0) {
11251: la1tokens[96 + j] = true;
11252: }
11253: }
11254: }
11255: }
11256: for (int i = 0; i < 114; i++) {
11257: if (la1tokens[i]) {
11258: jj_expentry = new int[1];
11259: jj_expentry[0] = i;
11260: jj_expentries.addElement(jj_expentry);
11261: }
11262: }
11263: jj_endpos = 0;
11264: jj_rescan_token();
11265: jj_add_error_token(0, 0);
11266: int[][] exptokseq = new int[jj_expentries.size()][];
11267: for (int i = 0; i < jj_expentries.size(); i++) {
11268: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
11269: }
11270: return new ParseException(token, exptokseq, tokenImage);
11271: }
11272:
11273: final public void enable_tracing() {
11274: }
11275:
11276: final public void disable_tracing() {
11277: }
11278:
11279: final private void jj_rescan_token() {
11280: jj_rescan = true;
11281: for (int i = 0; i < 27; i++) {
11282: JJCalls p = jj_2_rtns[i];
11283: do {
11284: if (p.gen > jj_gen) {
11285: jj_la = p.arg;
11286: jj_lastpos = jj_scanpos = p.first;
11287: switch (i) {
11288: case 0:
11289: jj_3_1();
11290: break;
11291: case 1:
11292: jj_3_2();
11293: break;
11294: case 2:
11295: jj_3_3();
11296: break;
11297: case 3:
11298: jj_3_4();
11299: break;
11300: case 4:
11301: jj_3_5();
11302: break;
11303: case 5:
11304: jj_3_6();
11305: break;
11306: case 6:
11307: jj_3_7();
11308: break;
11309: case 7:
11310: jj_3_8();
11311: break;
11312: case 8:
11313: jj_3_9();
11314: break;
11315: case 9:
11316: jj_3_10();
11317: break;
11318: case 10:
11319: jj_3_11();
11320: break;
11321: case 11:
11322: jj_3_12();
11323: break;
11324: case 12:
11325: jj_3_13();
11326: break;
11327: case 13:
11328: jj_3_14();
11329: break;
11330: case 14:
11331: jj_3_15();
11332: break;
11333: case 15:
11334: jj_3_16();
11335: break;
11336: case 16:
11337: jj_3_17();
11338: break;
11339: case 17:
11340: jj_3_18();
11341: break;
11342: case 18:
11343: jj_3_19();
11344: break;
11345: case 19:
11346: jj_3_20();
11347: break;
11348: case 20:
11349: jj_3_21();
11350: break;
11351: case 21:
11352: jj_3_22();
11353: break;
11354: case 22:
11355: jj_3_23();
11356: break;
11357: case 23:
11358: jj_3_24();
11359: break;
11360: case 24:
11361: jj_3_25();
11362: break;
11363: case 25:
11364: jj_3_26();
11365: break;
11366: case 26:
11367: jj_3_27();
11368: break;
11369: }
11370: }
11371: p = p.next;
11372: } while (p != null);
11373: }
11374: jj_rescan = false;
11375: }
11376:
11377: final private void jj_save(int index, int xla) {
11378: JJCalls p = jj_2_rtns[index];
11379: while (p.gen > jj_gen) {
11380: if (p.next == null) {
11381: p = p.next = new JJCalls();
11382: break;
11383: }
11384: p = p.next;
11385: }
11386: p.gen = jj_gen + xla - jj_la;
11387: p.first = token;
11388: p.arg = xla;
11389: }
11390:
11391: static final class JJCalls {
11392: int gen;
11393: Token first;
11394: int arg;
11395: JJCalls next;
11396: }
11397:
11398: }
|